]> 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
Added wx.combo.BitmapComboBox
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDouble swig_types[33]
2500 #define SWIGTYPE_p_wxDropFilesEvent swig_types[34]
2501 #define SWIGTYPE_p_wxDuplexMode swig_types[35]
2502 #define SWIGTYPE_p_wxEraseEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEvent swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoop swig_types[38]
2505 #define SWIGTYPE_p_wxEventLoopActivator swig_types[39]
2506 #define SWIGTYPE_p_wxEvtHandler swig_types[40]
2507 #define SWIGTYPE_p_wxFSFile swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystem swig_types[42]
2509 #define SWIGTYPE_p_wxFileSystemHandler swig_types[43]
2510 #define SWIGTYPE_p_wxFlexGridSizer swig_types[44]
2511 #define SWIGTYPE_p_wxFocusEvent swig_types[45]
2512 #define SWIGTYPE_p_wxFont swig_types[46]
2513 #define SWIGTYPE_p_wxFrame swig_types[47]
2514 #define SWIGTYPE_p_wxGBPosition swig_types[48]
2515 #define SWIGTYPE_p_wxGBSizerItem swig_types[49]
2516 #define SWIGTYPE_p_wxGBSpan swig_types[50]
2517 #define SWIGTYPE_p_wxGIFHandler swig_types[51]
2518 #define SWIGTYPE_p_wxGridBagSizer swig_types[52]
2519 #define SWIGTYPE_p_wxGridSizer swig_types[53]
2520 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[54]
2521 #define SWIGTYPE_p_wxICOHandler swig_types[55]
2522 #define SWIGTYPE_p_wxIconizeEvent swig_types[56]
2523 #define SWIGTYPE_p_wxIdleEvent swig_types[57]
2524 #define SWIGTYPE_p_wxImage swig_types[58]
2525 #define SWIGTYPE_p_wxImageHandler swig_types[59]
2526 #define SWIGTYPE_p_wxImageHistogram swig_types[60]
2527 #define SWIGTYPE_p_wxImage_HSVValue swig_types[61]
2528 #define SWIGTYPE_p_wxImage_RGBValue swig_types[62]
2529 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[63]
2530 #define SWIGTYPE_p_wxInitDialogEvent swig_types[64]
2531 #define SWIGTYPE_p_wxInputStream swig_types[65]
2532 #define SWIGTYPE_p_wxInternetFSHandler swig_types[66]
2533 #define SWIGTYPE_p_wxItemContainer swig_types[67]
2534 #define SWIGTYPE_p_wxJPEGHandler swig_types[68]
2535 #define SWIGTYPE_p_wxKeyEvent swig_types[69]
2536 #define SWIGTYPE_p_wxLayoutConstraints swig_types[70]
2537 #define SWIGTYPE_p_wxMaximizeEvent swig_types[71]
2538 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[72]
2539 #define SWIGTYPE_p_wxMenu swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBar swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBarBase swig_types[75]
2542 #define SWIGTYPE_p_wxMenuEvent swig_types[76]
2543 #define SWIGTYPE_p_wxMenuItem swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMoveEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNcPaintEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNotifyEvent swig_types[84]
2551 #define SWIGTYPE_p_wxObject swig_types[85]
2552 #define SWIGTYPE_p_wxOutputStream swig_types[86]
2553 #define SWIGTYPE_p_wxPCXHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNGHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNMHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPaintEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaperSize swig_types[92]
2559 #define SWIGTYPE_p_wxPoint swig_types[93]
2560 #define SWIGTYPE_p_wxPoint2D swig_types[94]
2561 #define SWIGTYPE_p_wxPropagateOnce swig_types[95]
2562 #define SWIGTYPE_p_wxPropagationDisabler swig_types[96]
2563 #define SWIGTYPE_p_wxPyApp swig_types[97]
2564 #define SWIGTYPE_p_wxPyCommandEvent swig_types[98]
2565 #define SWIGTYPE_p_wxPyDropTarget swig_types[99]
2566 #define SWIGTYPE_p_wxPyEvent swig_types[100]
2567 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyImageHandler swig_types[102]
2569 #define SWIGTYPE_p_wxPyInputStream swig_types[103]
2570 #define SWIGTYPE_p_wxPySizer swig_types[104]
2571 #define SWIGTYPE_p_wxPyValidator swig_types[105]
2572 #define SWIGTYPE_p_wxQuantize swig_types[106]
2573 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[107]
2574 #define SWIGTYPE_p_wxRealPoint swig_types[108]
2575 #define SWIGTYPE_p_wxRect swig_types[109]
2576 #define SWIGTYPE_p_wxRect2D swig_types[110]
2577 #define SWIGTYPE_p_wxRegion swig_types[111]
2578 #define SWIGTYPE_p_wxScrollEvent swig_types[112]
2579 #define SWIGTYPE_p_wxScrollWinEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSetCursorEvent swig_types[114]
2581 #define SWIGTYPE_p_wxShowEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSize swig_types[116]
2583 #define SWIGTYPE_p_wxSizeEvent swig_types[117]
2584 #define SWIGTYPE_p_wxSizer swig_types[118]
2585 #define SWIGTYPE_p_wxSizerItem swig_types[119]
2586 #define SWIGTYPE_p_wxStaticBox swig_types[120]
2587 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[121]
2588 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[122]
2589 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[123]
2590 #define SWIGTYPE_p_wxTGAHandler swig_types[124]
2591 #define SWIGTYPE_p_wxTIFFHandler swig_types[125]
2592 #define SWIGTYPE_p_wxToolTip swig_types[126]
2593 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[127]
2594 #define SWIGTYPE_p_wxValidator swig_types[128]
2595 #define SWIGTYPE_p_wxVisualAttributes swig_types[129]
2596 #define SWIGTYPE_p_wxWindow swig_types[130]
2597 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[131]
2598 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[132]
2599 #define SWIGTYPE_p_wxXPMHandler swig_types[133]
2600 #define SWIGTYPE_p_wxZipFSHandler swig_types[134]
2601 static swig_type_info *swig_types[136];
2602 static swig_module_info swig_module = {swig_types, 135, 0, 0, 0, 0};
2603 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2604 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2605
2606 /* -------- TYPES TABLE (END) -------- */
2607
2608 #if (PY_VERSION_HEX <= 0x02000000)
2609 # if !defined(SWIG_PYTHON_CLASSIC)
2610 # error "This python version requires to use swig with the '-classic' option"
2611 # endif
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodern' option"
2615 #endif
2616 #if (PY_VERSION_HEX <= 0x02020000)
2617 # error "This python version requires to use swig with the '-nomodernargs' option"
2618 #endif
2619 #ifndef METH_O
2620 # error "This python version requires to use swig with the '-nofastunpack' option"
2621 #endif
2622
2623 /*-----------------------------------------------
2624 @(target):= _core_.so
2625 ------------------------------------------------*/
2626 #define SWIG_init init_core_
2627
2628 #define SWIG_name "_core_"
2629
2630 #define SWIGVERSION 0x010329
2631
2632
2633 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2634 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2635
2636
2637 #include <stdexcept>
2638
2639
2640 namespace swig {
2641 class PyObject_ptr {
2642 protected:
2643 PyObject *_obj;
2644
2645 public:
2646 PyObject_ptr() :_obj(0)
2647 {
2648 }
2649
2650 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2651 {
2652 Py_XINCREF(_obj);
2653 }
2654
2655 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2656 {
2657 if (initial_ref) Py_XINCREF(_obj);
2658 }
2659
2660 PyObject_ptr & operator=(const PyObject_ptr& item)
2661 {
2662 Py_XINCREF(item._obj);
2663 Py_XDECREF(_obj);
2664 _obj = item._obj;
2665 return *this;
2666 }
2667
2668 ~PyObject_ptr()
2669 {
2670 Py_XDECREF(_obj);
2671 }
2672
2673 operator PyObject *() const
2674 {
2675 return _obj;
2676 }
2677
2678 PyObject *operator->() const
2679 {
2680 return _obj;
2681 }
2682 };
2683 }
2684
2685
2686 namespace swig {
2687 struct PyObject_var : PyObject_ptr {
2688 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2689
2690 PyObject_var & operator = (PyObject* obj)
2691 {
2692 Py_XDECREF(_obj);
2693 _obj = obj;
2694 return *this;
2695 }
2696 };
2697 }
2698
2699
2700 #include "wx/wxPython/wxPython_int.h"
2701 #include "wx/wxPython/pyclasses.h"
2702 #include "wx/wxPython/twoitem.h"
2703
2704
2705 #ifndef wxPyUSE_EXPORT
2706 // Helper functions for dealing with SWIG objects and such. These are
2707 // located here so they know about the SWIG types and functions declared
2708 // in the wrapper code.
2709
2710 #include <wx/hashmap.h>
2711 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2712
2713
2714 // Maintains a hashmap of className to swig_type_info pointers. Given the
2715 // name of a class either looks up the type info in the cache, or scans the
2716 // SWIG tables for it.
2717 extern PyObject* wxPyPtrTypeMap;
2718 static
2719 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2720
2721 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2722
2723 if (typeInfoCache == NULL)
2724 typeInfoCache = new wxPyTypeInfoHashMap;
2725
2726 wxString name(className);
2727 swig_type_info* swigType = (*typeInfoCache)[name];
2728
2729 if (! swigType) {
2730 // it wasn't in the cache, so look it up from SWIG
2731 name.Append(wxT(" *"));
2732 swigType = SWIG_TypeQuery(name.mb_str());
2733
2734 // if it still wasn't found, try looking for a mapped name
2735 if (!swigType) {
2736 PyObject* item;
2737 name = className;
2738
2739 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2740 (char*)(const char*)name.mbc_str())) != NULL) {
2741 name = wxString(PyString_AsString(item), *wxConvCurrent);
2742 name.Append(wxT(" *"));
2743 swigType = SWIG_TypeQuery(name.mb_str());
2744 }
2745 }
2746 if (swigType) {
2747 // and add it to the map if found
2748 (*typeInfoCache)[className] = swigType;
2749 }
2750 }
2751 return swigType;
2752 }
2753
2754
2755 // Check if a class name is a type known to SWIG
2756 bool wxPyCheckSwigType(const wxChar* className) {
2757
2758 swig_type_info* swigType = wxPyFindSwigType(className);
2759 return swigType != NULL;
2760 }
2761
2762
2763 // Given a pointer to a C++ object and a class name, construct a Python proxy
2764 // object for it.
2765 PyObject* wxPyConstructObject(void* ptr,
2766 const wxChar* className,
2767 int setThisOwn) {
2768
2769 swig_type_info* swigType = wxPyFindSwigType(className);
2770 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2771
2772 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2773 }
2774
2775
2776 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2777 // Ensures that the proxy object is of the specified (or derived) type. If
2778 // not able to perform the conversion then a Python exception is set and the
2779 // error should be handled properly in the caller. Returns True on success.
2780 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2781 const wxChar* className) {
2782
2783 swig_type_info* swigType = wxPyFindSwigType(className);
2784 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2785
2786 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2787 }
2788
2789
2790
2791 // Make a SWIGified pointer object suitable for a .this attribute
2792 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2793
2794 PyObject* robj = NULL;
2795
2796 swig_type_info* swigType = wxPyFindSwigType(className);
2797 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2798
2799 robj = PySwigObject_New(ptr, swigType, 0);
2800 return robj;
2801 }
2802
2803
2804 // Python's PyInstance_Check does not return True for instances of new-style
2805 // classes. This should get close enough for both new and old classes but I
2806 // should re-evaluate the need for doing instance checks...
2807 bool wxPyInstance_Check(PyObject* obj) {
2808 return PyObject_HasAttrString(obj, "__class__") != 0;
2809 }
2810
2811
2812 // This one checks if the object is an instance of a SWIG proxy class (it has
2813 // a .this attribute, and the .this attribute is a PySwigObject.)
2814 bool wxPySwigInstance_Check(PyObject* obj) {
2815 static PyObject* this_str = NULL;
2816 if (this_str == NULL)
2817 this_str = PyString_FromString("this");
2818
2819 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2820 if (this_attr) {
2821 bool retval = (PySwigObject_Check(this_attr) != 0);
2822 Py_DECREF(this_attr);
2823 return retval;
2824 }
2825
2826 PyErr_Clear();
2827 return false;
2828 }
2829
2830
2831 // Export a C API in a struct. Other modules will be able to load this from
2832 // the wx._core_ module and will then have safe access to these functions,
2833 // even if they are located in another shared library.
2834 static wxPyCoreAPI API = {
2835
2836 wxPyCheckSwigType,
2837 wxPyConstructObject,
2838 wxPyConvertSwigPtr,
2839 wxPyMakeSwigPtr,
2840
2841 wxPyBeginAllowThreads,
2842 wxPyEndAllowThreads,
2843 wxPyBeginBlockThreads,
2844 wxPyEndBlockThreads,
2845
2846 wxPy_ConvertList,
2847
2848 wxString_in_helper,
2849 Py2wxString,
2850 wx2PyString,
2851
2852 byte_LIST_helper,
2853 int_LIST_helper,
2854 long_LIST_helper,
2855 string_LIST_helper,
2856 wxPoint_LIST_helper,
2857 wxBitmap_LIST_helper,
2858 wxString_LIST_helper,
2859 wxAcceleratorEntry_LIST_helper,
2860
2861 wxSize_helper,
2862 wxPoint_helper,
2863 wxRealPoint_helper,
2864 wxRect_helper,
2865 wxColour_helper,
2866 wxPoint2D_helper,
2867
2868 wxPySimple_typecheck,
2869 wxColour_typecheck,
2870
2871 wxPyCBH_setCallbackInfo,
2872 wxPyCBH_findCallback,
2873 wxPyCBH_callCallback,
2874 wxPyCBH_callCallbackObj,
2875 wxPyCBH_delete,
2876
2877 wxPyMake_wxObject,
2878 wxPyMake_wxSizer,
2879 wxPyPtrTypeMap_Add,
2880 wxPy2int_seq_helper,
2881 wxPy4int_seq_helper,
2882 wxArrayString2PyList_helper,
2883 wxArrayInt2PyList_helper,
2884
2885 wxPyClientData_dtor,
2886 wxPyUserData_dtor,
2887 wxPyOORClientData_dtor,
2888
2889 wxPyCBInputStream_create,
2890 wxPyCBInputStream_copy,
2891
2892 wxPyInstance_Check,
2893 wxPySwigInstance_Check,
2894
2895 wxPyCheckForApp,
2896
2897 wxArrayDouble2PyList_helper,
2898 wxPoint2D_LIST_helper,
2899 wxRect2D_helper,
2900
2901 };
2902
2903 #endif
2904
2905
2906 #if !WXWIN_COMPATIBILITY_2_4
2907 #define wxHIDE_READONLY 0
2908 #endif
2909
2910
2911 #define SWIG_From_long PyInt_FromLong
2912
2913
2914 SWIGINTERNINLINE PyObject *
2915 SWIG_From_int (int value)
2916 {
2917 return SWIG_From_long (value);
2918 }
2919
2920 static const wxString wxPyEmptyString(wxEmptyString);
2921 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2922 return self->GetClassInfo()->GetClassName();
2923 }
2924 SWIGINTERN void wxObject_Destroy(wxObject *self){
2925 delete self;
2926 }
2927
2928 #ifndef __WXMAC__
2929 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2930 #endif
2931
2932
2933 #include <limits.h>
2934 #ifndef LLONG_MIN
2935 # define LLONG_MIN LONG_LONG_MIN
2936 #endif
2937 #ifndef LLONG_MAX
2938 # define LLONG_MAX LONG_LONG_MAX
2939 #endif
2940 #ifndef ULLONG_MAX
2941 # define ULLONG_MAX ULONG_LONG_MAX
2942 #endif
2943
2944
2945 SWIGINTERN int
2946 SWIG_AsVal_long (PyObject* obj, long* val)
2947 {
2948 if (PyNumber_Check(obj)) {
2949 if (val) *val = PyInt_AsLong(obj);
2950 return SWIG_OK;
2951 }
2952 return SWIG_TypeError;
2953 }
2954
2955
2956 SWIGINTERN int
2957 SWIG_AsVal_int (PyObject * obj, int *val)
2958 {
2959 long v;
2960 int res = SWIG_AsVal_long (obj, &v);
2961 if (SWIG_IsOK(res)) {
2962 if ((v < INT_MIN || v > INT_MAX)) {
2963 return SWIG_OverflowError;
2964 } else {
2965 if (val) *val = static_cast< int >(v);
2966 }
2967 }
2968 return res;
2969 }
2970
2971 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2972 wxSize temp, *obj = &temp;
2973 if ( other == Py_None ) return false;
2974 if ( ! wxSize_helper(other, &obj) ) {
2975 PyErr_Clear();
2976 return false;
2977 }
2978 return self->operator==(*obj);
2979 }
2980 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2981 wxSize temp, *obj = &temp;
2982 if ( other == Py_None ) return true;
2983 if ( ! wxSize_helper(other, &obj)) {
2984 PyErr_Clear();
2985 return true;
2986 }
2987 return self->operator!=(*obj);
2988 }
2989
2990 #include <float.h>
2991
2992
2993 SWIGINTERN int
2994 SWIG_AsVal_double (PyObject *obj, double* val)
2995 {
2996 if (PyNumber_Check(obj)) {
2997 if (val) *val = PyFloat_AsDouble(obj);
2998 return SWIG_OK;
2999 }
3000 return SWIG_TypeError;
3001 }
3002
3003
3004 SWIGINTERN int
3005 SWIG_AsVal_float (PyObject * obj, float *val)
3006 {
3007 double v;
3008 int res = SWIG_AsVal_double (obj, &v);
3009 if (SWIG_IsOK(res)) {
3010 if ((v < -FLT_MAX || v > FLT_MAX)) {
3011 return SWIG_OverflowError;
3012 } else {
3013 if (val) *val = static_cast< float >(v);
3014 }
3015 }
3016 return res;
3017 }
3018
3019 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3020 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3021 PyObject* tup = PyTuple_New(2);
3022 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3023 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3024 //wxPyEndBlockThreads(blocked);
3025 return tup;
3026 }
3027
3028 #define SWIG_From_double PyFloat_FromDouble
3029
3030 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3031 wxRealPoint temp, *obj = &temp;
3032 if ( other == Py_None ) return false;
3033 if ( ! wxRealPoint_helper(other, &obj) ) {
3034 PyErr_Clear();
3035 return false;
3036 }
3037 return self->operator==(*obj);
3038 }
3039 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3040 wxRealPoint temp, *obj = &temp;
3041 if ( other == Py_None ) return true;
3042 if ( ! wxRealPoint_helper(other, &obj)) {
3043 PyErr_Clear();
3044 return true;
3045 }
3046 return self->operator!=(*obj);
3047 }
3048 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3049 self->x = x;
3050 self->y = y;
3051 }
3052 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3053 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3054 PyObject* tup = PyTuple_New(2);
3055 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3056 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3057 //PyEndBlockThreads(blocked);
3058 return tup;
3059 }
3060 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3061 wxPoint temp, *obj = &temp;
3062 if ( other == Py_None ) return false;
3063 if ( ! wxPoint_helper(other, &obj) ) {
3064 PyErr_Clear();
3065 return false;
3066 }
3067 return self->operator==(*obj);
3068 }
3069 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3070 wxPoint temp, *obj = &temp;
3071 if ( other == Py_None ) return true;
3072 if ( ! wxPoint_helper(other, &obj)) {
3073 PyErr_Clear();
3074 return true;
3075 }
3076 return self->operator!=(*obj);
3077 }
3078 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3079 self->x = x;
3080 self->y = y;
3081 }
3082 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3083 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3084 PyObject* tup = PyTuple_New(2);
3085 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3086 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3087 //wxPyEndBlockThreads(blocked);
3088 return tup;
3089 }
3090 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3091 wxRect temp, *obj = &temp;
3092 if ( other == Py_None ) return false;
3093 if ( ! wxRect_helper(other, &obj) ) {
3094 PyErr_Clear();
3095 return false;
3096 }
3097 return self->operator==(*obj);
3098 }
3099 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3100 wxRect temp, *obj = &temp;
3101 if ( other == Py_None ) return true;
3102 if ( ! wxRect_helper(other, &obj)) {
3103 PyErr_Clear();
3104 return true;
3105 }
3106 return self->operator!=(*obj);
3107 }
3108 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3109 self->x = x;
3110 self->y = y;
3111 self->width = width;
3112 self->height = height;
3113 }
3114 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3115 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3116 PyObject* tup = PyTuple_New(4);
3117 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3118 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3119 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3120 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3121 //wxPyEndBlockThreads(blocked);
3122 return tup;
3123 }
3124
3125 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3126 wxRegion reg1(*r1);
3127 wxRegion reg2(*r2);
3128 wxRect dest(0,0,0,0);
3129 PyObject* obj;
3130
3131 reg1.Intersect(reg2);
3132 dest = reg1.GetBox();
3133
3134 if (dest != wxRect(0,0,0,0)) {
3135 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3136 wxRect* newRect = new wxRect(dest);
3137 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3138 //wxPyEndBlockThreads(blocked);
3139 return obj;
3140 }
3141 Py_INCREF(Py_None);
3142 return Py_None;
3143 }
3144
3145 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3146 wxPoint2D temp, *obj = &temp;
3147 if ( other == Py_None ) return false;
3148 if ( ! wxPoint2D_helper(other, &obj) ) {
3149 PyErr_Clear();
3150 return false;
3151 }
3152 return self->operator==(*obj);
3153 }
3154 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3155 wxPoint2D temp, *obj = &temp;
3156 if ( other == Py_None ) return true;
3157 if ( ! wxPoint2D_helper(other, &obj)) {
3158 PyErr_Clear();
3159 return true;
3160 }
3161 return self->operator!=(*obj);
3162 }
3163 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3164 self->m_x = x;
3165 self->m_y = y;
3166 }
3167 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3168 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3169 PyObject* tup = PyTuple_New(2);
3170 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3171 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3172 //wxPyEndBlockThreads(blocked);
3173 return tup;
3174 }
3175 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3176 wxRect2D temp, *obj = &temp;
3177 if ( other == Py_None ) return false;
3178 if ( ! wxRect2D_helper(other, &obj) ) {
3179 PyErr_Clear();
3180 return false;
3181 }
3182 return self->operator==(*obj);
3183 }
3184 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3185 wxRect2D temp, *obj = &temp;
3186 if ( other == Py_None ) return true;
3187 if ( ! wxRect2D_helper(other, &obj)) {
3188 PyErr_Clear();
3189 return true;
3190 }
3191 return self->operator!=(*obj);
3192 }
3193 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3194 self->m_x = x;
3195 self->m_y = y;
3196 self->m_width = width;
3197 self->m_height = height;
3198 }
3199 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3200 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3201 PyObject* tup = PyTuple_New(4);
3202 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3203 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3204 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3205 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3206 //wxPyEndBlockThreads(blocked);
3207 return tup;
3208 }
3209
3210 #include "wx/wxPython/pyistream.h"
3211
3212 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3213 wxInputStream* wxis = wxPyCBInputStream::create(p);
3214 if (wxis)
3215 return new wxPyInputStream(wxis);
3216 else
3217 return NULL;
3218 }
3219
3220 SWIGINTERN swig_type_info*
3221 SWIG_pchar_descriptor()
3222 {
3223 static int init = 0;
3224 static swig_type_info* info = 0;
3225 if (!init) {
3226 info = SWIG_TypeQuery("_p_char");
3227 init = 1;
3228 }
3229 return info;
3230 }
3231
3232
3233 SWIGINTERNINLINE PyObject *
3234 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3235 {
3236 if (carray) {
3237 if (size > INT_MAX) {
3238 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3239 return pchar_descriptor ?
3240 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3241 } else {
3242 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3243 }
3244 } else {
3245 return SWIG_Py_Void();
3246 }
3247 }
3248
3249
3250 SWIGINTERNINLINE PyObject *
3251 SWIG_From_char (char c)
3252 {
3253 return SWIG_FromCharPtrAndSize(&c,1);
3254 }
3255
3256
3257 SWIGINTERNINLINE PyObject*
3258 SWIG_From_unsigned_SS_long (unsigned long value)
3259 {
3260 return (value > LONG_MAX) ?
3261 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3262 }
3263
3264
3265 SWIGINTERNINLINE PyObject *
3266 SWIG_From_size_t (size_t value)
3267 {
3268 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3269 }
3270
3271
3272 SWIGINTERN int
3273 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3274 {
3275 if (PyString_Check(obj)) {
3276 char *cstr; Py_ssize_t len;
3277 PyString_AsStringAndSize(obj, &cstr, &len);
3278 if (cptr) {
3279 if (alloc) {
3280 /*
3281 In python the user should not be able to modify the inner
3282 string representation. To warranty that, if you define
3283 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3284 buffer is always returned.
3285
3286 The default behavior is just to return the pointer value,
3287 so, be careful.
3288 */
3289 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3290 if (*alloc != SWIG_OLDOBJ)
3291 #else
3292 if (*alloc == SWIG_NEWOBJ)
3293 #endif
3294 {
3295 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3296 *alloc = SWIG_NEWOBJ;
3297 }
3298 else {
3299 *cptr = cstr;
3300 *alloc = SWIG_OLDOBJ;
3301 }
3302 } else {
3303 *cptr = PyString_AsString(obj);
3304 }
3305 }
3306 if (psize) *psize = len + 1;
3307 return SWIG_OK;
3308 } else {
3309 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3310 if (pchar_descriptor) {
3311 void* vptr = 0;
3312 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3313 if (cptr) *cptr = (char *) vptr;
3314 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3315 if (alloc) *alloc = SWIG_OLDOBJ;
3316 return SWIG_OK;
3317 }
3318 }
3319 }
3320 return SWIG_TypeError;
3321 }
3322
3323
3324 SWIGINTERN int
3325 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3326 {
3327 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3328 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3329 if (SWIG_IsOK(res)) {
3330 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3331 if (csize <= size) {
3332 if (val) {
3333 if (csize) memcpy(val, cptr, csize*sizeof(char));
3334 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3335 }
3336 if (alloc == SWIG_NEWOBJ) {
3337 delete[] cptr;
3338 res = SWIG_DelNewMask(res);
3339 }
3340 return res;
3341 }
3342 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3343 }
3344 return SWIG_TypeError;
3345 }
3346
3347
3348 SWIGINTERN int
3349 SWIG_AsVal_char (PyObject * obj, char *val)
3350 {
3351 int res = SWIG_AsCharArray(obj, val, 1);
3352 if (!SWIG_IsOK(res)) {
3353 long v;
3354 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3355 if (SWIG_IsOK(res)) {
3356 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3357 if (val) *val = static_cast< char >(v);
3358 } else {
3359 res = SWIG_OverflowError;
3360 }
3361 }
3362 }
3363 return res;
3364 }
3365
3366 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3367 // We use only strings for the streams, not unicode
3368 PyObject* str = PyObject_Str(obj);
3369 if (! str) {
3370 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3371 return;
3372 }
3373 self->Write(PyString_AS_STRING(str),
3374 PyString_GET_SIZE(str));
3375 Py_DECREF(str);
3376 }
3377
3378 #include "wx/wxPython/pyistream.h"
3379
3380
3381 class wxPyFileSystemHandler : public wxFileSystemHandler
3382 {
3383 public:
3384 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3385
3386 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3387 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3388 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3389 DEC_PYCALLBACK_STRING__pure(FindNext);
3390
3391 wxString GetProtocol(const wxString& location) {
3392 return wxFileSystemHandler::GetProtocol(location);
3393 }
3394
3395 wxString GetLeftLocation(const wxString& location) {
3396 return wxFileSystemHandler::GetLeftLocation(location);
3397 }
3398
3399 wxString GetAnchor(const wxString& location) {
3400 return wxFileSystemHandler::GetAnchor(location);
3401 }
3402
3403 wxString GetRightLocation(const wxString& location) {
3404 return wxFileSystemHandler::GetRightLocation(location);
3405 }
3406
3407 wxString GetMimeTypeFromExt(const wxString& location) {
3408 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3409 }
3410
3411 PYPRIVATE;
3412 };
3413
3414
3415 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3416 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3417 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3418 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3419
3420
3421 SWIGINTERN int
3422 SWIG_AsVal_bool (PyObject *obj, bool *val)
3423 {
3424 if (obj == Py_True) {
3425 if (val) *val = true;
3426 return SWIG_OK;
3427 } else if (obj == Py_False) {
3428 if (val) *val = false;
3429 return SWIG_OK;
3430 } else {
3431 long v = 0;
3432 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3433 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3434 return res;
3435 }
3436 }
3437
3438 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3439 wxFileName fname = wxFileSystem::URLToFileName(url);
3440 return fname.GetFullPath();
3441 }
3442
3443 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3444 wxImage& image,
3445 long type) {
3446 wxMemoryFSHandler::AddFile(filename, image, type);
3447 }
3448
3449 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3450 const wxBitmap& bitmap,
3451 long type) {
3452 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3453 }
3454
3455 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3456 PyObject* data) {
3457 if (! PyString_Check(data)) {
3458 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3459 "Expected string object"));
3460 return;
3461 }
3462
3463 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3464 void* ptr = (void*)PyString_AsString(data);
3465 size_t size = PyString_Size(data);
3466 wxPyEndBlockThreads(blocked);
3467
3468 wxMemoryFSHandler::AddFile(filename, ptr, size);
3469 }
3470
3471
3472 #include "wx/wxPython/pyistream.h"
3473
3474
3475 SWIGINTERN int
3476 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3477 {
3478 long v = 0;
3479 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3480 return SWIG_TypeError;
3481 }
3482 else if (val)
3483 *val = (unsigned long)v;
3484 return SWIG_OK;
3485 }
3486
3487
3488 SWIGINTERN int
3489 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3490 {
3491 unsigned long v;
3492 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3493 if (SWIG_IsOK(res)) {
3494 if ((v > UCHAR_MAX)) {
3495 return SWIG_OverflowError;
3496 } else {
3497 if (val) *val = static_cast< unsigned char >(v);
3498 }
3499 }
3500 return res;
3501 }
3502
3503
3504 SWIGINTERNINLINE PyObject *
3505 SWIG_From_unsigned_SS_char (unsigned char value)
3506 {
3507 return SWIG_From_unsigned_SS_long (value);
3508 }
3509
3510 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3511 wxImageHistogramEntry e = (*self)[key];
3512 return e.value;
3513 }
3514 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3515 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3516 wxImageHistogramEntry e = (*self)[key];
3517 return e.value;
3518 }
3519 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3520 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3521 colour.Green(),
3522 colour.Blue());
3523 wxImageHistogramEntry e = (*self)[key];
3524 return e.value;
3525 }
3526
3527 // Pull the nested class out to the top level for SWIG's sake
3528 #define wxImage_RGBValue wxImage::RGBValue
3529 #define wxImage_HSVValue wxImage::HSVValue
3530
3531 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3532 if (width > 0 && height > 0)
3533 return new wxImage(width, height, clear);
3534 else
3535 return new wxImage;
3536 }
3537 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3538 return new wxImage(bitmap.ConvertToImage());
3539 }
3540 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3541 if (DATASIZE != width*height*3) {
3542 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3543 return NULL;
3544 }
3545
3546 // Copy the source data so the wxImage can clean it up later
3547 buffer copy = (buffer)malloc(DATASIZE);
3548 if (copy == NULL) {
3549 wxPyBLOCK_THREADS(PyErr_NoMemory());
3550 return NULL;
3551 }
3552 memcpy(copy, data, DATASIZE);
3553 return new wxImage(width, height, copy, false);
3554 }
3555 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3556 if (DATASIZE != width*height*3) {
3557 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3558 return NULL;
3559 }
3560 if (ALPHASIZE != width*height) {
3561 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3562 return NULL;
3563 }
3564
3565 // Copy the source data so the wxImage can clean it up later
3566 buffer dcopy = (buffer)malloc(DATASIZE);
3567 if (dcopy == NULL) {
3568 wxPyBLOCK_THREADS(PyErr_NoMemory());
3569 return NULL;
3570 }
3571 memcpy(dcopy, data, DATASIZE);
3572
3573 buffer acopy = (buffer)malloc(ALPHASIZE);
3574 if (acopy == NULL) {
3575 wxPyBLOCK_THREADS(PyErr_NoMemory());
3576 return NULL;
3577 }
3578 memcpy(acopy, alpha, ALPHASIZE);
3579
3580 return new wxImage(width, height, dcopy, acopy, false);
3581 }
3582 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3583 wxSize size(self->GetWidth(), self->GetHeight());
3584 return size;
3585 }
3586 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3587 buffer data = self->GetData();
3588 int len = self->GetWidth() * self->GetHeight() * 3;
3589 PyObject* rv;
3590 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3591 return rv;
3592 }
3593 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3594 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3595 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3596 return;
3597 }
3598 buffer copy = (buffer)malloc(DATASIZE);
3599 if (copy == NULL) {
3600 wxPyBLOCK_THREADS(PyErr_NoMemory());
3601 return;
3602 }
3603 memcpy(copy, data, DATASIZE);
3604 self->SetData(copy, false);
3605 // wxImage takes ownership of copy...
3606 }
3607 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3608 buffer data = self->GetData();
3609 int len = self->GetWidth() * self->GetHeight() * 3;
3610 PyObject* rv;
3611 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3612 return rv;
3613 }
3614 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3615 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3616 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3617 return;
3618 }
3619 self->SetData(data, true);
3620 }
3621 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3622 buffer data = self->GetAlpha();
3623 if (! data) {
3624 RETURN_NONE();
3625 } else {
3626 int len = self->GetWidth() * self->GetHeight();
3627 PyObject* rv;
3628 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3629 return rv;
3630 }
3631 }
3632 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3633 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3634 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3635 return;
3636 }
3637 buffer acopy = (buffer)malloc(ALPHASIZE);
3638 if (acopy == NULL) {
3639 wxPyBLOCK_THREADS(PyErr_NoMemory());
3640 return;
3641 }
3642 memcpy(acopy, alpha, ALPHASIZE);
3643 self->SetAlpha(acopy, false);
3644 // wxImage takes ownership of acopy...
3645 }
3646 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3647 buffer data = self->GetAlpha();
3648 int len = self->GetWidth() * self->GetHeight();
3649 PyObject* rv;
3650 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3651 return rv;
3652 }
3653 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3654 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3655 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3656 return;
3657 }
3658 self->SetAlpha(alpha, true);
3659 }
3660 SWIGINTERN PyObject *wxImage_GetHandlers(){
3661 wxList& list = wxImage::GetHandlers();
3662 return wxPy_ConvertList(&list);
3663 }
3664 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3665 wxBitmap bitmap(*self, depth);
3666 return bitmap;
3667 }
3668 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3669 wxImage mono = self->ConvertToMono( red, green, blue );
3670 wxBitmap bitmap( mono, 1 );
3671 return bitmap;
3672 }
3673
3674 wxImage* _ImageFromBuffer(int width, int height,
3675 buffer data, int DATASIZE,
3676 buffer alpha=NULL, int ALPHASIZE=0)
3677 {
3678 if (DATASIZE != width*height*3) {
3679 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3680 return NULL;
3681 }
3682 if (alpha != NULL) {
3683 if (ALPHASIZE != width*height) {
3684 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3685 return NULL;
3686 }
3687 return new wxImage(width, height, data, alpha, true);
3688 }
3689 return new wxImage(width, height, data, true);
3690 }
3691
3692 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3693 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3694 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3695 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3696 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3697 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3698 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3699 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3700 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3701 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3702 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3703 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3704 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3705 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3706 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3707
3708 #include <wx/imagtga.h>
3709
3710
3711 #include <wx/quantize.h>
3712
3713 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3714 return wxQuantize::Quantize(src, dest,
3715 //NULL, // palette
3716 desiredNoColours,
3717 NULL, // eightBitData
3718 flags);
3719 }
3720 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3721 if (PyCallable_Check(func)) {
3722 self->Connect(id, lastId, eventType,
3723 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3724 new wxPyCallback(func));
3725 }
3726 else if (func == Py_None) {
3727 self->Disconnect(id, lastId, eventType,
3728 (wxObjectEventFunction)
3729 &wxPyCallback::EventThunker);
3730 }
3731 else {
3732 wxPyBLOCK_THREADS(
3733 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3734 }
3735 }
3736 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3737 return self->Disconnect(id, lastId, eventType,
3738 (wxObjectEventFunction)
3739 &wxPyCallback::EventThunker);
3740 }
3741 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3742 if (_self && _self != Py_None) {
3743 self->SetClientObject(new wxPyOORClientData(_self, incref));
3744 }
3745 else {
3746 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3747 if (data) {
3748 self->SetClientObject(NULL); // This will delete it too
3749 }
3750 }
3751 }
3752
3753 #if ! wxUSE_HOTKEY
3754 #define wxEVT_HOTKEY -9999
3755 #endif
3756
3757 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3758 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3759 if (data) {
3760 Py_INCREF(data->m_obj);
3761 return data->m_obj;
3762 } else {
3763 Py_INCREF(Py_None);
3764 return Py_None;
3765 }
3766 }
3767 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3768 wxPyClientData* data = new wxPyClientData(clientData);
3769 self->SetClientObject(data);
3770 }
3771 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3772 #if wxUSE_UNICODE
3773 return self->GetUnicodeKey();
3774 #else
3775 return 0;
3776 #endif
3777 }
3778 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3779 #if wxUSE_UNICODE
3780 self->m_uniChar = uniChar;
3781 #endif
3782 }
3783
3784 SWIGINTERNINLINE PyObject *
3785 SWIG_From_unsigned_SS_int (unsigned int value)
3786 {
3787 return SWIG_From_unsigned_SS_long (value);
3788 }
3789
3790
3791 SWIGINTERN int
3792 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3793 {
3794 unsigned long v;
3795 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3796 if (SWIG_IsOK(res)) {
3797 if ((v > UINT_MAX)) {
3798 return SWIG_OverflowError;
3799 } else {
3800 if (val) *val = static_cast< unsigned int >(v);
3801 }
3802 }
3803 return res;
3804 }
3805
3806 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3807 self->m_size = size;
3808 }
3809 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3810 int count = self->GetNumberOfFiles();
3811 wxString* files = self->GetFiles();
3812 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3813 PyObject* list = PyList_New(count);
3814
3815 if (!list) {
3816 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3817 wxPyEndBlockThreads(blocked);
3818 return NULL;
3819 }
3820
3821 for (int i=0; i<count; i++) {
3822 PyList_SetItem(list, i, wx2PyString(files[i]));
3823 }
3824 wxPyEndBlockThreads(blocked);
3825 return list;
3826 }
3827
3828
3829 SWIGINTERN wxPyApp *new_wxPyApp(){
3830 wxPythonApp = new wxPyApp();
3831 return wxPythonApp;
3832 }
3833 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3834 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3835 return wxPyTestDisplayAvailable();
3836 }
3837
3838 void wxApp_CleanUp() {
3839 __wxPyCleanup();
3840 }
3841
3842
3843 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3844
3845
3846
3847
3848
3849 SWIGINTERNINLINE PyObject *
3850 SWIG_FromCharPtr(const char *cptr)
3851 {
3852 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3853 }
3854
3855
3856 #if 0 // #ifdef __WXMAC__
3857
3858 // A dummy class that raises an exception if used...
3859 class wxEventLoop
3860 {
3861 public:
3862 wxEventLoop() { wxPyRaiseNotImplemented(); }
3863 int Run() { return 0; }
3864 void Exit(int rc = 0) {}
3865 bool Pending() const { return false; }
3866 bool Dispatch() { return false; }
3867 bool IsRunning() const { return false; }
3868 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3869 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3870 };
3871
3872 #else
3873
3874 #include <wx/evtloop.h>
3875
3876 #endif
3877
3878
3879
3880 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3881 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3882 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3883 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3884 wxWindowList& list = self->GetChildren();
3885 return wxPy_ConvertList(&list);
3886 }
3887 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3888 #if wxUSE_HOTKEY
3889 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3890 #else
3891 return false;
3892 #endif
3893 }
3894 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3895
3896
3897
3898 return false;
3899
3900 }
3901 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3902 return wxPyGetWinHandle(self);
3903 }
3904 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3905 self->AssociateHandle((WXWidget)handle);
3906 }
3907 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3908
3909 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3910 return wxWindow::FindWindowById(id, parent);
3911 }
3912
3913 wxWindow* wxFindWindowByName( const wxString& name,
3914 const wxWindow *parent = NULL ) {
3915 return wxWindow::FindWindowByName(name, parent);
3916 }
3917
3918 wxWindow* wxFindWindowByLabel( const wxString& label,
3919 const wxWindow *parent = NULL ) {
3920 return wxWindow::FindWindowByLabel(label, parent);
3921 }
3922
3923
3924 #ifdef __WXMSW__
3925 #include <wx/msw/private.h> // to get wxGetWindowId
3926 #endif
3927
3928
3929 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3930 #ifdef __WXMSW__
3931 WXHWND hWnd = (WXHWND)_hWnd;
3932 long id = wxGetWindowId(hWnd);
3933 wxWindow* win = new wxWindow;
3934 if (parent)
3935 parent->AddChild(win);
3936 win->SetEventHandler(win);
3937 win->SetHWND(hWnd);
3938 win->SetId(id);
3939 win->SubclassWin(hWnd);
3940 win->AdoptAttributesFromHWND();
3941 win->SetupColours();
3942 return win;
3943 #else
3944 wxPyRaiseNotImplemented();
3945 return NULL;
3946 #endif
3947 }
3948
3949
3950 PyObject* GetTopLevelWindows() {
3951 return wxPy_ConvertList(&wxTopLevelWindows);
3952 }
3953
3954
3955 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3956 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3957 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3958
3959 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3960
3961
3962 SWIGINTERNINLINE int
3963 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3964 {
3965 unsigned long v;
3966 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3967 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3968 return res;
3969 }
3970
3971 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3972 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3973 wxMenuItemList& list = self->GetMenuItems();
3974 return wxPy_ConvertList(&list);
3975 }
3976 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3977 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3978 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3979 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3980 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3981 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3982 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3983 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3984 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3985 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3986 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3987 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3988 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3989 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3990 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3991 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3992 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3993 static const wxString wxPyControlNameStr(wxControlNameStr);
3994 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3995 if (clientData) {
3996 wxPyClientData* data = new wxPyClientData(clientData);
3997 return self->Append(item, data);
3998 } else
3999 return self->Append(item);
4000 }
4001 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
4002 if (clientData) {
4003 wxPyClientData* data = new wxPyClientData(clientData);
4004 return self->Insert(item, pos, data);
4005 } else
4006 return self->Insert(item, pos);
4007 }
4008 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
4009 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
4010 if (data) {
4011 Py_INCREF(data->m_obj);
4012 return data->m_obj;
4013 } else {
4014 Py_INCREF(Py_None);
4015 return Py_None;
4016 }
4017 }
4018 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
4019 wxPyClientData* data = new wxPyClientData(clientData);
4020 self->SetClientObject(n, data);
4021 }
4022
4023
4024 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4025 wxPyUserData* data = NULL;
4026 if ( userData ) {
4027 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4028 data = new wxPyUserData(userData);
4029 wxPyEndBlockThreads(blocked);
4030 }
4031 return new wxSizerItem(window, proportion, flag, border, data);
4032 }
4033 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4034 wxPyUserData* data = NULL;
4035 if ( userData ) {
4036 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4037 data = new wxPyUserData(userData);
4038 wxPyEndBlockThreads(blocked);
4039 }
4040 return new wxSizerItem(width, height, proportion, flag, border, data);
4041 }
4042 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4043 wxPyUserData* data = NULL;
4044 if ( userData ) {
4045 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4046 data = new wxPyUserData(userData);
4047 wxPyEndBlockThreads(blocked);
4048 }
4049 return new wxSizerItem(sizer, proportion, flag, border, data);
4050 }
4051
4052 SWIGINTERNINLINE PyObject *
4053 SWIG_From_float (float value)
4054 {
4055 return SWIG_From_double (value);
4056 }
4057
4058 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4059 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4060 if (data) {
4061 Py_INCREF(data->m_obj);
4062 return data->m_obj;
4063 } else {
4064 Py_INCREF(Py_None);
4065 return Py_None;
4066 }
4067 }
4068 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4069 wxPyUserData* data = NULL;
4070 if ( userData ) {
4071 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4072 data = new wxPyUserData(userData);
4073 wxPyEndBlockThreads(blocked);
4074 }
4075 self->SetUserData(data);
4076 }
4077
4078 // Figure out the type of the sizer item
4079
4080 struct wxPySizerItemInfo {
4081 wxPySizerItemInfo()
4082 : window(NULL), sizer(NULL), gotSize(false),
4083 size(wxDefaultSize), gotPos(false), pos(-1)
4084 {}
4085
4086 wxWindow* window;
4087 wxSizer* sizer;
4088 bool gotSize;
4089 wxSize size;
4090 bool gotPos;
4091 int pos;
4092 };
4093
4094 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4095
4096 wxPySizerItemInfo info;
4097 wxSize size;
4098 wxSize* sizePtr = &size;
4099
4100 // Find out what the type of the item is
4101 // try wxWindow
4102 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4103 PyErr_Clear();
4104 info.window = NULL;
4105
4106 // try wxSizer
4107 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4108 PyErr_Clear();
4109 info.sizer = NULL;
4110
4111 // try wxSize or (w,h)
4112 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4113 info.size = *sizePtr;
4114 info.gotSize = true;
4115 }
4116
4117 // or a single int
4118 if (checkIdx && PyInt_Check(item)) {
4119 info.pos = PyInt_AsLong(item);
4120 info.gotPos = true;
4121 }
4122 }
4123 }
4124
4125 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4126 // no expected type, figure out what kind of error message to generate
4127 if ( !checkSize && !checkIdx )
4128 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4129 else if ( checkSize && !checkIdx )
4130 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4131 else if ( !checkSize && checkIdx)
4132 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4133 else
4134 // can this one happen?
4135 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4136 }
4137
4138 return info;
4139 }
4140
4141 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4142 if (!self->GetClientObject())
4143 self->SetClientObject(new wxPyOORClientData(_self));
4144 }
4145 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4146
4147 wxPyUserData* data = NULL;
4148 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4149 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4150 if ( userData && (info.window || info.sizer || info.gotSize) )
4151 data = new wxPyUserData(userData);
4152 if ( info.sizer )
4153 PyObject_SetAttrString(item,"thisown",Py_False);
4154 wxPyEndBlockThreads(blocked);
4155
4156 // Now call the real Add method if a valid item type was found
4157 if ( info.window )
4158 return self->Add(info.window, proportion, flag, border, data);
4159 else if ( info.sizer )
4160 return self->Add(info.sizer, proportion, flag, border, data);
4161 else if (info.gotSize)
4162 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4163 proportion, flag, border, data);
4164 else
4165 return NULL;
4166 }
4167 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4168
4169 wxPyUserData* data = NULL;
4170 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4171 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4172 if ( userData && (info.window || info.sizer || info.gotSize) )
4173 data = new wxPyUserData(userData);
4174 if ( info.sizer )
4175 PyObject_SetAttrString(item,"thisown",Py_False);
4176 wxPyEndBlockThreads(blocked);
4177
4178 // Now call the real Insert method if a valid item type was found
4179 if ( info.window )
4180 return self->Insert(before, info.window, proportion, flag, border, data);
4181 else if ( info.sizer )
4182 return self->Insert(before, info.sizer, proportion, flag, border, data);
4183 else if (info.gotSize)
4184 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4185 proportion, flag, border, data);
4186 else
4187 return NULL;
4188 }
4189 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4190
4191 wxPyUserData* data = NULL;
4192 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4193 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4194 if ( userData && (info.window || info.sizer || info.gotSize) )
4195 data = new wxPyUserData(userData);
4196 if ( info.sizer )
4197 PyObject_SetAttrString(item,"thisown",Py_False);
4198 wxPyEndBlockThreads(blocked);
4199
4200 // Now call the real Prepend method if a valid item type was found
4201 if ( info.window )
4202 return self->Prepend(info.window, proportion, flag, border, data);
4203 else if ( info.sizer )
4204 return self->Prepend(info.sizer, proportion, flag, border, data);
4205 else if (info.gotSize)
4206 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4207 proportion, flag, border, data);
4208 else
4209 return NULL;
4210 }
4211 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4212 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4213 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4214 wxPyEndBlockThreads(blocked);
4215 if ( info.window )
4216 return self->Remove(info.window);
4217 else if ( info.sizer )
4218 return self->Remove(info.sizer);
4219 else if ( info.gotPos )
4220 return self->Remove(info.pos);
4221 else
4222 return false;
4223 }
4224 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4225 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4226 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4227 wxPyEndBlockThreads(blocked);
4228 if ( info.window )
4229 return self->Detach(info.window);
4230 else if ( info.sizer )
4231 return self->Detach(info.sizer);
4232 else if ( info.gotPos )
4233 return self->Detach(info.pos);
4234 else
4235 return false;
4236 }
4237 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4238 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4239 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4240 wxPyEndBlockThreads(blocked);
4241 if ( info.window )
4242 return self->GetItem(info.window);
4243 else if ( info.sizer )
4244 return self->GetItem(info.sizer);
4245 else if ( info.gotPos )
4246 return self->GetItem(info.pos);
4247 else
4248 return NULL;
4249 }
4250 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4251 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4252 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4253 wxPyEndBlockThreads(blocked);
4254 if ( info.window )
4255 self->SetItemMinSize(info.window, size);
4256 else if ( info.sizer )
4257 self->SetItemMinSize(info.sizer, size);
4258 else if ( info.gotPos )
4259 self->SetItemMinSize(info.pos, size);
4260 }
4261 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4262 wxSizerItemList& list = self->GetChildren();
4263 return wxPy_ConvertList(&list);
4264 }
4265 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4266 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4267 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4268 wxPyEndBlockThreads(blocked);
4269 if ( info.window )
4270 return self->Show(info.window, show, recursive);
4271 else if ( info.sizer )
4272 return self->Show(info.sizer, show, recursive);
4273 else if ( info.gotPos )
4274 return self->Show(info.pos, show);
4275 else
4276 return false;
4277 }
4278 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4279 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4280 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4281 wxPyEndBlockThreads(blocked);
4282 if ( info.window )
4283 return self->IsShown(info.window);
4284 else if ( info.sizer )
4285 return self->IsShown(info.sizer);
4286 else if ( info.gotPos )
4287 return self->IsShown(info.pos);
4288 else
4289 return false;
4290 }
4291
4292 // See pyclasses.h
4293 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4294 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4295 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4296
4297
4298
4299
4300 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4301 {
4302 if (source == Py_None) {
4303 **obj = wxGBPosition(-1,-1);
4304 return true;
4305 }
4306 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4307 }
4308
4309 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4310 {
4311 if (source == Py_None) {
4312 **obj = wxGBSpan(-1,-1);
4313 return true;
4314 }
4315 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4316 }
4317
4318
4319 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4320 wxGBPosition temp, *obj = &temp;
4321 if ( other == Py_None ) return false;
4322 if ( ! wxGBPosition_helper(other, &obj) ) {
4323 PyErr_Clear();
4324 return false;
4325 }
4326 return self->operator==(*obj);
4327 }
4328 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4329 wxGBPosition temp, *obj = &temp;
4330 if ( other == Py_None ) return true;
4331 if ( ! wxGBPosition_helper(other, &obj)) {
4332 PyErr_Clear();
4333 return true;
4334 }
4335 return self->operator!=(*obj);
4336 }
4337 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4338 self->SetRow(row);
4339 self->SetCol(col);
4340 }
4341 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4342 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4343 PyObject* tup = PyTuple_New(2);
4344 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4345 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4346 wxPyEndBlockThreads(blocked);
4347 return tup;
4348 }
4349 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4350 wxGBSpan temp, *obj = &temp;
4351 if ( other == Py_None ) return false;
4352 if ( ! wxGBSpan_helper(other, &obj) ) {
4353 PyErr_Clear();
4354 return false;
4355 }
4356 return self->operator==(*obj);
4357 }
4358 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4359 wxGBSpan temp, *obj = &temp;
4360 if ( other == Py_None ) return true;
4361 if ( ! wxGBSpan_helper(other, &obj)) {
4362 PyErr_Clear();
4363 return true;
4364 }
4365 return self->operator!=(*obj);
4366 }
4367 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4368 self->SetRowspan(rowspan);
4369 self->SetColspan(colspan);
4370 }
4371 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4372 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4373 PyObject* tup = PyTuple_New(2);
4374 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4375 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4376 wxPyEndBlockThreads(blocked);
4377 return tup;
4378 }
4379 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4380 wxPyUserData* data = NULL;
4381 if ( userData ) {
4382 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4383 data = new wxPyUserData(userData);
4384 wxPyEndBlockThreads(blocked);
4385 }
4386 return new wxGBSizerItem(window, pos, span, flag, border, data);
4387 }
4388 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4389 wxPyUserData* data = NULL;
4390 if ( userData ) {
4391 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4392 data = new wxPyUserData(userData);
4393 wxPyEndBlockThreads(blocked);
4394 }
4395 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4396 }
4397 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4398 wxPyUserData* data = NULL;
4399 if ( userData ) {
4400 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4401 data = new wxPyUserData(userData);
4402 wxPyEndBlockThreads(blocked);
4403 }
4404 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4405 }
4406 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4407 int row, col;
4408 self->GetEndPos(row, col);
4409 return wxGBPosition(row, col);
4410 }
4411 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4412
4413 wxPyUserData* data = NULL;
4414 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4415 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4416 if ( userData && (info.window || info.sizer || info.gotSize) )
4417 data = new wxPyUserData(userData);
4418 if ( info.sizer )
4419 PyObject_SetAttrString(item,"thisown",Py_False);
4420 wxPyEndBlockThreads(blocked);
4421
4422 // Now call the real Add method if a valid item type was found
4423 if ( info.window )
4424 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4425 else if ( info.sizer )
4426 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4427 else if (info.gotSize)
4428 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4429 pos, span, flag, border, data);
4430 return NULL;
4431 }
4432
4433
4434 #ifdef __cplusplus
4435 extern "C" {
4436 #endif
4437 SWIGINTERN int EmptyString_set(PyObject *) {
4438 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4439 return 1;
4440 }
4441
4442
4443 SWIGINTERN PyObject *EmptyString_get(void) {
4444 PyObject *pyobj = 0;
4445
4446 {
4447 #if wxUSE_UNICODE
4448 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4449 #else
4450 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4451 #endif
4452 }
4453 return pyobj;
4454 }
4455
4456
4457 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4458 PyObject *resultobj = 0;
4459 wxObject *arg1 = (wxObject *) 0 ;
4460 wxString result;
4461 void *argp1 = 0 ;
4462 int res1 = 0 ;
4463 PyObject *swig_obj[1] ;
4464
4465 if (!args) SWIG_fail;
4466 swig_obj[0] = args;
4467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4468 if (!SWIG_IsOK(res1)) {
4469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4470 }
4471 arg1 = reinterpret_cast< wxObject * >(argp1);
4472 {
4473 PyThreadState* __tstate = wxPyBeginAllowThreads();
4474 result = wxObject_GetClassName(arg1);
4475 wxPyEndAllowThreads(__tstate);
4476 if (PyErr_Occurred()) SWIG_fail;
4477 }
4478 {
4479 #if wxUSE_UNICODE
4480 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4481 #else
4482 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4483 #endif
4484 }
4485 return resultobj;
4486 fail:
4487 return NULL;
4488 }
4489
4490
4491 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4492 PyObject *resultobj = 0;
4493 wxObject *arg1 = (wxObject *) 0 ;
4494 void *argp1 = 0 ;
4495 int res1 = 0 ;
4496 PyObject *swig_obj[1] ;
4497
4498 if (!args) SWIG_fail;
4499 swig_obj[0] = args;
4500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4501 if (!SWIG_IsOK(res1)) {
4502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4503 }
4504 arg1 = reinterpret_cast< wxObject * >(argp1);
4505 {
4506 PyThreadState* __tstate = wxPyBeginAllowThreads();
4507 wxObject_Destroy(arg1);
4508 wxPyEndAllowThreads(__tstate);
4509 if (PyErr_Occurred()) SWIG_fail;
4510 }
4511 resultobj = SWIG_Py_Void();
4512 return resultobj;
4513 fail:
4514 return NULL;
4515 }
4516
4517
4518 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4519 PyObject *resultobj = 0;
4520 wxObject *arg1 = (wxObject *) 0 ;
4521 wxObject *arg2 = 0 ;
4522 bool result;
4523 void *argp1 = 0 ;
4524 int res1 = 0 ;
4525 void *argp2 = 0 ;
4526 int res2 = 0 ;
4527 PyObject * obj0 = 0 ;
4528 PyObject * obj1 = 0 ;
4529 char * kwnames[] = {
4530 (char *) "self",(char *) "p", NULL
4531 };
4532
4533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4535 if (!SWIG_IsOK(res1)) {
4536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4537 }
4538 arg1 = reinterpret_cast< wxObject * >(argp1);
4539 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4540 if (!SWIG_IsOK(res2)) {
4541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4542 }
4543 if (!argp2) {
4544 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4545 }
4546 arg2 = reinterpret_cast< wxObject * >(argp2);
4547 {
4548 PyThreadState* __tstate = wxPyBeginAllowThreads();
4549 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4550 wxPyEndAllowThreads(__tstate);
4551 if (PyErr_Occurred()) SWIG_fail;
4552 }
4553 {
4554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4555 }
4556 return resultobj;
4557 fail:
4558 return NULL;
4559 }
4560
4561
4562 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4563 PyObject *obj;
4564 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4565 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4566 return SWIG_Py_Void();
4567 }
4568
4569 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4570 PyObject *resultobj = 0;
4571 wxSize *arg1 = (wxSize *) 0 ;
4572 int arg2 ;
4573 void *argp1 = 0 ;
4574 int res1 = 0 ;
4575 int val2 ;
4576 int ecode2 = 0 ;
4577 PyObject *swig_obj[2] ;
4578
4579 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4581 if (!SWIG_IsOK(res1)) {
4582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4583 }
4584 arg1 = reinterpret_cast< wxSize * >(argp1);
4585 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4586 if (!SWIG_IsOK(ecode2)) {
4587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4588 }
4589 arg2 = static_cast< int >(val2);
4590 if (arg1) (arg1)->x = arg2;
4591
4592 resultobj = SWIG_Py_Void();
4593 return resultobj;
4594 fail:
4595 return NULL;
4596 }
4597
4598
4599 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4600 PyObject *resultobj = 0;
4601 wxSize *arg1 = (wxSize *) 0 ;
4602 int result;
4603 void *argp1 = 0 ;
4604 int res1 = 0 ;
4605 PyObject *swig_obj[1] ;
4606
4607 if (!args) SWIG_fail;
4608 swig_obj[0] = args;
4609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4610 if (!SWIG_IsOK(res1)) {
4611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4612 }
4613 arg1 = reinterpret_cast< wxSize * >(argp1);
4614 result = (int) ((arg1)->x);
4615 resultobj = SWIG_From_int(static_cast< int >(result));
4616 return resultobj;
4617 fail:
4618 return NULL;
4619 }
4620
4621
4622 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4623 PyObject *resultobj = 0;
4624 wxSize *arg1 = (wxSize *) 0 ;
4625 int arg2 ;
4626 void *argp1 = 0 ;
4627 int res1 = 0 ;
4628 int val2 ;
4629 int ecode2 = 0 ;
4630 PyObject *swig_obj[2] ;
4631
4632 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4634 if (!SWIG_IsOK(res1)) {
4635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4636 }
4637 arg1 = reinterpret_cast< wxSize * >(argp1);
4638 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4639 if (!SWIG_IsOK(ecode2)) {
4640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4641 }
4642 arg2 = static_cast< int >(val2);
4643 if (arg1) (arg1)->y = arg2;
4644
4645 resultobj = SWIG_Py_Void();
4646 return resultobj;
4647 fail:
4648 return NULL;
4649 }
4650
4651
4652 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4653 PyObject *resultobj = 0;
4654 wxSize *arg1 = (wxSize *) 0 ;
4655 int result;
4656 void *argp1 = 0 ;
4657 int res1 = 0 ;
4658 PyObject *swig_obj[1] ;
4659
4660 if (!args) SWIG_fail;
4661 swig_obj[0] = args;
4662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4663 if (!SWIG_IsOK(res1)) {
4664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4665 }
4666 arg1 = reinterpret_cast< wxSize * >(argp1);
4667 result = (int) ((arg1)->y);
4668 resultobj = SWIG_From_int(static_cast< int >(result));
4669 return resultobj;
4670 fail:
4671 return NULL;
4672 }
4673
4674
4675 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4676 PyObject *resultobj = 0;
4677 int arg1 = (int) 0 ;
4678 int arg2 = (int) 0 ;
4679 wxSize *result = 0 ;
4680 int val1 ;
4681 int ecode1 = 0 ;
4682 int val2 ;
4683 int ecode2 = 0 ;
4684 PyObject * obj0 = 0 ;
4685 PyObject * obj1 = 0 ;
4686 char * kwnames[] = {
4687 (char *) "w",(char *) "h", NULL
4688 };
4689
4690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4691 if (obj0) {
4692 ecode1 = SWIG_AsVal_int(obj0, &val1);
4693 if (!SWIG_IsOK(ecode1)) {
4694 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4695 }
4696 arg1 = static_cast< int >(val1);
4697 }
4698 if (obj1) {
4699 ecode2 = SWIG_AsVal_int(obj1, &val2);
4700 if (!SWIG_IsOK(ecode2)) {
4701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4702 }
4703 arg2 = static_cast< int >(val2);
4704 }
4705 {
4706 result = (wxSize *)new wxSize(arg1,arg2);
4707 if (PyErr_Occurred()) SWIG_fail;
4708 }
4709 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4710 return resultobj;
4711 fail:
4712 return NULL;
4713 }
4714
4715
4716 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4717 PyObject *resultobj = 0;
4718 wxSize *arg1 = (wxSize *) 0 ;
4719 void *argp1 = 0 ;
4720 int res1 = 0 ;
4721 PyObject *swig_obj[1] ;
4722
4723 if (!args) SWIG_fail;
4724 swig_obj[0] = args;
4725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4726 if (!SWIG_IsOK(res1)) {
4727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4728 }
4729 arg1 = reinterpret_cast< wxSize * >(argp1);
4730 {
4731 delete arg1;
4732
4733 if (PyErr_Occurred()) SWIG_fail;
4734 }
4735 resultobj = SWIG_Py_Void();
4736 return resultobj;
4737 fail:
4738 return NULL;
4739 }
4740
4741
4742 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4743 PyObject *resultobj = 0;
4744 wxSize *arg1 = (wxSize *) 0 ;
4745 PyObject *arg2 = (PyObject *) 0 ;
4746 bool result;
4747 void *argp1 = 0 ;
4748 int res1 = 0 ;
4749 PyObject * obj0 = 0 ;
4750 PyObject * obj1 = 0 ;
4751 char * kwnames[] = {
4752 (char *) "self",(char *) "other", NULL
4753 };
4754
4755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4757 if (!SWIG_IsOK(res1)) {
4758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4759 }
4760 arg1 = reinterpret_cast< wxSize * >(argp1);
4761 arg2 = obj1;
4762 {
4763 result = (bool)wxSize___eq__(arg1,arg2);
4764 if (PyErr_Occurred()) SWIG_fail;
4765 }
4766 {
4767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4768 }
4769 return resultobj;
4770 fail:
4771 return NULL;
4772 }
4773
4774
4775 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4776 PyObject *resultobj = 0;
4777 wxSize *arg1 = (wxSize *) 0 ;
4778 PyObject *arg2 = (PyObject *) 0 ;
4779 bool result;
4780 void *argp1 = 0 ;
4781 int res1 = 0 ;
4782 PyObject * obj0 = 0 ;
4783 PyObject * obj1 = 0 ;
4784 char * kwnames[] = {
4785 (char *) "self",(char *) "other", NULL
4786 };
4787
4788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4790 if (!SWIG_IsOK(res1)) {
4791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4792 }
4793 arg1 = reinterpret_cast< wxSize * >(argp1);
4794 arg2 = obj1;
4795 {
4796 result = (bool)wxSize___ne__(arg1,arg2);
4797 if (PyErr_Occurred()) SWIG_fail;
4798 }
4799 {
4800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4801 }
4802 return resultobj;
4803 fail:
4804 return NULL;
4805 }
4806
4807
4808 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4809 PyObject *resultobj = 0;
4810 wxSize *arg1 = (wxSize *) 0 ;
4811 wxSize *arg2 = 0 ;
4812 wxSize result;
4813 void *argp1 = 0 ;
4814 int res1 = 0 ;
4815 wxSize temp2 ;
4816 PyObject * obj0 = 0 ;
4817 PyObject * obj1 = 0 ;
4818 char * kwnames[] = {
4819 (char *) "self",(char *) "sz", NULL
4820 };
4821
4822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4824 if (!SWIG_IsOK(res1)) {
4825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4826 }
4827 arg1 = reinterpret_cast< wxSize * >(argp1);
4828 {
4829 arg2 = &temp2;
4830 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4831 }
4832 {
4833 result = (arg1)->operator +((wxSize const &)*arg2);
4834 if (PyErr_Occurred()) SWIG_fail;
4835 }
4836 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4837 return resultobj;
4838 fail:
4839 return NULL;
4840 }
4841
4842
4843 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4844 PyObject *resultobj = 0;
4845 wxSize *arg1 = (wxSize *) 0 ;
4846 wxSize *arg2 = 0 ;
4847 wxSize result;
4848 void *argp1 = 0 ;
4849 int res1 = 0 ;
4850 wxSize temp2 ;
4851 PyObject * obj0 = 0 ;
4852 PyObject * obj1 = 0 ;
4853 char * kwnames[] = {
4854 (char *) "self",(char *) "sz", NULL
4855 };
4856
4857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4859 if (!SWIG_IsOK(res1)) {
4860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4861 }
4862 arg1 = reinterpret_cast< wxSize * >(argp1);
4863 {
4864 arg2 = &temp2;
4865 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4866 }
4867 {
4868 result = (arg1)->operator -((wxSize const &)*arg2);
4869 if (PyErr_Occurred()) SWIG_fail;
4870 }
4871 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4872 return resultobj;
4873 fail:
4874 return NULL;
4875 }
4876
4877
4878 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4879 PyObject *resultobj = 0;
4880 wxSize *arg1 = (wxSize *) 0 ;
4881 wxSize *arg2 = 0 ;
4882 void *argp1 = 0 ;
4883 int res1 = 0 ;
4884 wxSize temp2 ;
4885 PyObject * obj0 = 0 ;
4886 PyObject * obj1 = 0 ;
4887 char * kwnames[] = {
4888 (char *) "self",(char *) "sz", NULL
4889 };
4890
4891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4893 if (!SWIG_IsOK(res1)) {
4894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4895 }
4896 arg1 = reinterpret_cast< wxSize * >(argp1);
4897 {
4898 arg2 = &temp2;
4899 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4900 }
4901 {
4902 (arg1)->IncTo((wxSize const &)*arg2);
4903 if (PyErr_Occurred()) SWIG_fail;
4904 }
4905 resultobj = SWIG_Py_Void();
4906 return resultobj;
4907 fail:
4908 return NULL;
4909 }
4910
4911
4912 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4913 PyObject *resultobj = 0;
4914 wxSize *arg1 = (wxSize *) 0 ;
4915 wxSize *arg2 = 0 ;
4916 void *argp1 = 0 ;
4917 int res1 = 0 ;
4918 wxSize temp2 ;
4919 PyObject * obj0 = 0 ;
4920 PyObject * obj1 = 0 ;
4921 char * kwnames[] = {
4922 (char *) "self",(char *) "sz", NULL
4923 };
4924
4925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4927 if (!SWIG_IsOK(res1)) {
4928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4929 }
4930 arg1 = reinterpret_cast< wxSize * >(argp1);
4931 {
4932 arg2 = &temp2;
4933 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4934 }
4935 {
4936 (arg1)->DecTo((wxSize const &)*arg2);
4937 if (PyErr_Occurred()) SWIG_fail;
4938 }
4939 resultobj = SWIG_Py_Void();
4940 return resultobj;
4941 fail:
4942 return NULL;
4943 }
4944
4945
4946 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4947 PyObject *resultobj = 0;
4948 wxSize *arg1 = (wxSize *) 0 ;
4949 int arg2 ;
4950 int arg3 ;
4951 void *argp1 = 0 ;
4952 int res1 = 0 ;
4953 int val2 ;
4954 int ecode2 = 0 ;
4955 int val3 ;
4956 int ecode3 = 0 ;
4957 PyObject * obj0 = 0 ;
4958 PyObject * obj1 = 0 ;
4959 PyObject * obj2 = 0 ;
4960 char * kwnames[] = {
4961 (char *) "self",(char *) "dx",(char *) "dy", NULL
4962 };
4963
4964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4966 if (!SWIG_IsOK(res1)) {
4967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4968 }
4969 arg1 = reinterpret_cast< wxSize * >(argp1);
4970 ecode2 = SWIG_AsVal_int(obj1, &val2);
4971 if (!SWIG_IsOK(ecode2)) {
4972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4973 }
4974 arg2 = static_cast< int >(val2);
4975 ecode3 = SWIG_AsVal_int(obj2, &val3);
4976 if (!SWIG_IsOK(ecode3)) {
4977 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4978 }
4979 arg3 = static_cast< int >(val3);
4980 {
4981 (arg1)->IncBy(arg2,arg3);
4982 if (PyErr_Occurred()) SWIG_fail;
4983 }
4984 resultobj = SWIG_Py_Void();
4985 return resultobj;
4986 fail:
4987 return NULL;
4988 }
4989
4990
4991 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4992 PyObject *resultobj = 0;
4993 wxSize *arg1 = (wxSize *) 0 ;
4994 int arg2 ;
4995 int arg3 ;
4996 void *argp1 = 0 ;
4997 int res1 = 0 ;
4998 int val2 ;
4999 int ecode2 = 0 ;
5000 int val3 ;
5001 int ecode3 = 0 ;
5002 PyObject * obj0 = 0 ;
5003 PyObject * obj1 = 0 ;
5004 PyObject * obj2 = 0 ;
5005 char * kwnames[] = {
5006 (char *) "self",(char *) "dx",(char *) "dy", NULL
5007 };
5008
5009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5011 if (!SWIG_IsOK(res1)) {
5012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
5013 }
5014 arg1 = reinterpret_cast< wxSize * >(argp1);
5015 ecode2 = SWIG_AsVal_int(obj1, &val2);
5016 if (!SWIG_IsOK(ecode2)) {
5017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5018 }
5019 arg2 = static_cast< int >(val2);
5020 ecode3 = SWIG_AsVal_int(obj2, &val3);
5021 if (!SWIG_IsOK(ecode3)) {
5022 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5023 }
5024 arg3 = static_cast< int >(val3);
5025 {
5026 (arg1)->DecBy(arg2,arg3);
5027 if (PyErr_Occurred()) SWIG_fail;
5028 }
5029 resultobj = SWIG_Py_Void();
5030 return resultobj;
5031 fail:
5032 return NULL;
5033 }
5034
5035
5036 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5037 PyObject *resultobj = 0;
5038 wxSize *arg1 = (wxSize *) 0 ;
5039 float arg2 ;
5040 float arg3 ;
5041 void *argp1 = 0 ;
5042 int res1 = 0 ;
5043 float val2 ;
5044 int ecode2 = 0 ;
5045 float val3 ;
5046 int ecode3 = 0 ;
5047 PyObject * obj0 = 0 ;
5048 PyObject * obj1 = 0 ;
5049 PyObject * obj2 = 0 ;
5050 char * kwnames[] = {
5051 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5052 };
5053
5054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5056 if (!SWIG_IsOK(res1)) {
5057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5058 }
5059 arg1 = reinterpret_cast< wxSize * >(argp1);
5060 ecode2 = SWIG_AsVal_float(obj1, &val2);
5061 if (!SWIG_IsOK(ecode2)) {
5062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5063 }
5064 arg2 = static_cast< float >(val2);
5065 ecode3 = SWIG_AsVal_float(obj2, &val3);
5066 if (!SWIG_IsOK(ecode3)) {
5067 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5068 }
5069 arg3 = static_cast< float >(val3);
5070 {
5071 (arg1)->Scale(arg2,arg3);
5072 if (PyErr_Occurred()) SWIG_fail;
5073 }
5074 resultobj = SWIG_Py_Void();
5075 return resultobj;
5076 fail:
5077 return NULL;
5078 }
5079
5080
5081 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5082 PyObject *resultobj = 0;
5083 wxSize *arg1 = (wxSize *) 0 ;
5084 int arg2 ;
5085 int arg3 ;
5086 void *argp1 = 0 ;
5087 int res1 = 0 ;
5088 int val2 ;
5089 int ecode2 = 0 ;
5090 int val3 ;
5091 int ecode3 = 0 ;
5092 PyObject * obj0 = 0 ;
5093 PyObject * obj1 = 0 ;
5094 PyObject * obj2 = 0 ;
5095 char * kwnames[] = {
5096 (char *) "self",(char *) "w",(char *) "h", NULL
5097 };
5098
5099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5101 if (!SWIG_IsOK(res1)) {
5102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5103 }
5104 arg1 = reinterpret_cast< wxSize * >(argp1);
5105 ecode2 = SWIG_AsVal_int(obj1, &val2);
5106 if (!SWIG_IsOK(ecode2)) {
5107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5108 }
5109 arg2 = static_cast< int >(val2);
5110 ecode3 = SWIG_AsVal_int(obj2, &val3);
5111 if (!SWIG_IsOK(ecode3)) {
5112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5113 }
5114 arg3 = static_cast< int >(val3);
5115 {
5116 (arg1)->Set(arg2,arg3);
5117 if (PyErr_Occurred()) SWIG_fail;
5118 }
5119 resultobj = SWIG_Py_Void();
5120 return resultobj;
5121 fail:
5122 return NULL;
5123 }
5124
5125
5126 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5127 PyObject *resultobj = 0;
5128 wxSize *arg1 = (wxSize *) 0 ;
5129 int arg2 ;
5130 void *argp1 = 0 ;
5131 int res1 = 0 ;
5132 int val2 ;
5133 int ecode2 = 0 ;
5134 PyObject * obj0 = 0 ;
5135 PyObject * obj1 = 0 ;
5136 char * kwnames[] = {
5137 (char *) "self",(char *) "w", NULL
5138 };
5139
5140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5142 if (!SWIG_IsOK(res1)) {
5143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5144 }
5145 arg1 = reinterpret_cast< wxSize * >(argp1);
5146 ecode2 = SWIG_AsVal_int(obj1, &val2);
5147 if (!SWIG_IsOK(ecode2)) {
5148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5149 }
5150 arg2 = static_cast< int >(val2);
5151 {
5152 (arg1)->SetWidth(arg2);
5153 if (PyErr_Occurred()) SWIG_fail;
5154 }
5155 resultobj = SWIG_Py_Void();
5156 return resultobj;
5157 fail:
5158 return NULL;
5159 }
5160
5161
5162 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5163 PyObject *resultobj = 0;
5164 wxSize *arg1 = (wxSize *) 0 ;
5165 int arg2 ;
5166 void *argp1 = 0 ;
5167 int res1 = 0 ;
5168 int val2 ;
5169 int ecode2 = 0 ;
5170 PyObject * obj0 = 0 ;
5171 PyObject * obj1 = 0 ;
5172 char * kwnames[] = {
5173 (char *) "self",(char *) "h", NULL
5174 };
5175
5176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5178 if (!SWIG_IsOK(res1)) {
5179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5180 }
5181 arg1 = reinterpret_cast< wxSize * >(argp1);
5182 ecode2 = SWIG_AsVal_int(obj1, &val2);
5183 if (!SWIG_IsOK(ecode2)) {
5184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5185 }
5186 arg2 = static_cast< int >(val2);
5187 {
5188 (arg1)->SetHeight(arg2);
5189 if (PyErr_Occurred()) SWIG_fail;
5190 }
5191 resultobj = SWIG_Py_Void();
5192 return resultobj;
5193 fail:
5194 return NULL;
5195 }
5196
5197
5198 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5199 PyObject *resultobj = 0;
5200 wxSize *arg1 = (wxSize *) 0 ;
5201 int result;
5202 void *argp1 = 0 ;
5203 int res1 = 0 ;
5204 PyObject *swig_obj[1] ;
5205
5206 if (!args) SWIG_fail;
5207 swig_obj[0] = args;
5208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5209 if (!SWIG_IsOK(res1)) {
5210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5211 }
5212 arg1 = reinterpret_cast< wxSize * >(argp1);
5213 {
5214 result = (int)((wxSize const *)arg1)->GetWidth();
5215 if (PyErr_Occurred()) SWIG_fail;
5216 }
5217 resultobj = SWIG_From_int(static_cast< int >(result));
5218 return resultobj;
5219 fail:
5220 return NULL;
5221 }
5222
5223
5224 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5225 PyObject *resultobj = 0;
5226 wxSize *arg1 = (wxSize *) 0 ;
5227 int result;
5228 void *argp1 = 0 ;
5229 int res1 = 0 ;
5230 PyObject *swig_obj[1] ;
5231
5232 if (!args) SWIG_fail;
5233 swig_obj[0] = args;
5234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5235 if (!SWIG_IsOK(res1)) {
5236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5237 }
5238 arg1 = reinterpret_cast< wxSize * >(argp1);
5239 {
5240 result = (int)((wxSize const *)arg1)->GetHeight();
5241 if (PyErr_Occurred()) SWIG_fail;
5242 }
5243 resultobj = SWIG_From_int(static_cast< int >(result));
5244 return resultobj;
5245 fail:
5246 return NULL;
5247 }
5248
5249
5250 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5251 PyObject *resultobj = 0;
5252 wxSize *arg1 = (wxSize *) 0 ;
5253 bool result;
5254 void *argp1 = 0 ;
5255 int res1 = 0 ;
5256 PyObject *swig_obj[1] ;
5257
5258 if (!args) SWIG_fail;
5259 swig_obj[0] = args;
5260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5261 if (!SWIG_IsOK(res1)) {
5262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5263 }
5264 arg1 = reinterpret_cast< wxSize * >(argp1);
5265 {
5266 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5267 if (PyErr_Occurred()) SWIG_fail;
5268 }
5269 {
5270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5271 }
5272 return resultobj;
5273 fail:
5274 return NULL;
5275 }
5276
5277
5278 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5279 PyObject *resultobj = 0;
5280 wxSize *arg1 = (wxSize *) 0 ;
5281 wxSize *arg2 = 0 ;
5282 void *argp1 = 0 ;
5283 int res1 = 0 ;
5284 wxSize temp2 ;
5285 PyObject * obj0 = 0 ;
5286 PyObject * obj1 = 0 ;
5287 char * kwnames[] = {
5288 (char *) "self",(char *) "size", NULL
5289 };
5290
5291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5293 if (!SWIG_IsOK(res1)) {
5294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5295 }
5296 arg1 = reinterpret_cast< wxSize * >(argp1);
5297 {
5298 arg2 = &temp2;
5299 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5300 }
5301 {
5302 (arg1)->SetDefaults((wxSize const &)*arg2);
5303 if (PyErr_Occurred()) SWIG_fail;
5304 }
5305 resultobj = SWIG_Py_Void();
5306 return resultobj;
5307 fail:
5308 return NULL;
5309 }
5310
5311
5312 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5313 PyObject *resultobj = 0;
5314 wxSize *arg1 = (wxSize *) 0 ;
5315 PyObject *result = 0 ;
5316 void *argp1 = 0 ;
5317 int res1 = 0 ;
5318 PyObject *swig_obj[1] ;
5319
5320 if (!args) SWIG_fail;
5321 swig_obj[0] = args;
5322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5323 if (!SWIG_IsOK(res1)) {
5324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5325 }
5326 arg1 = reinterpret_cast< wxSize * >(argp1);
5327 {
5328 result = (PyObject *)wxSize_Get(arg1);
5329 if (PyErr_Occurred()) SWIG_fail;
5330 }
5331 resultobj = result;
5332 return resultobj;
5333 fail:
5334 return NULL;
5335 }
5336
5337
5338 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5339 PyObject *obj;
5340 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5341 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5342 return SWIG_Py_Void();
5343 }
5344
5345 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5346 return SWIG_Python_InitShadowInstance(args);
5347 }
5348
5349 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5350 PyObject *resultobj = 0;
5351 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5352 double arg2 ;
5353 void *argp1 = 0 ;
5354 int res1 = 0 ;
5355 double val2 ;
5356 int ecode2 = 0 ;
5357 PyObject *swig_obj[2] ;
5358
5359 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5361 if (!SWIG_IsOK(res1)) {
5362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5363 }
5364 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5365 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5366 if (!SWIG_IsOK(ecode2)) {
5367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5368 }
5369 arg2 = static_cast< double >(val2);
5370 if (arg1) (arg1)->x = arg2;
5371
5372 resultobj = SWIG_Py_Void();
5373 return resultobj;
5374 fail:
5375 return NULL;
5376 }
5377
5378
5379 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5380 PyObject *resultobj = 0;
5381 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5382 double result;
5383 void *argp1 = 0 ;
5384 int res1 = 0 ;
5385 PyObject *swig_obj[1] ;
5386
5387 if (!args) SWIG_fail;
5388 swig_obj[0] = args;
5389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5390 if (!SWIG_IsOK(res1)) {
5391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5392 }
5393 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5394 result = (double) ((arg1)->x);
5395 resultobj = SWIG_From_double(static_cast< double >(result));
5396 return resultobj;
5397 fail:
5398 return NULL;
5399 }
5400
5401
5402 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5403 PyObject *resultobj = 0;
5404 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5405 double arg2 ;
5406 void *argp1 = 0 ;
5407 int res1 = 0 ;
5408 double val2 ;
5409 int ecode2 = 0 ;
5410 PyObject *swig_obj[2] ;
5411
5412 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5414 if (!SWIG_IsOK(res1)) {
5415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5416 }
5417 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5418 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5419 if (!SWIG_IsOK(ecode2)) {
5420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5421 }
5422 arg2 = static_cast< double >(val2);
5423 if (arg1) (arg1)->y = arg2;
5424
5425 resultobj = SWIG_Py_Void();
5426 return resultobj;
5427 fail:
5428 return NULL;
5429 }
5430
5431
5432 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5433 PyObject *resultobj = 0;
5434 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5435 double result;
5436 void *argp1 = 0 ;
5437 int res1 = 0 ;
5438 PyObject *swig_obj[1] ;
5439
5440 if (!args) SWIG_fail;
5441 swig_obj[0] = args;
5442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5443 if (!SWIG_IsOK(res1)) {
5444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5445 }
5446 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5447 result = (double) ((arg1)->y);
5448 resultobj = SWIG_From_double(static_cast< double >(result));
5449 return resultobj;
5450 fail:
5451 return NULL;
5452 }
5453
5454
5455 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5456 PyObject *resultobj = 0;
5457 double arg1 = (double) 0.0 ;
5458 double arg2 = (double) 0.0 ;
5459 wxRealPoint *result = 0 ;
5460 double val1 ;
5461 int ecode1 = 0 ;
5462 double val2 ;
5463 int ecode2 = 0 ;
5464 PyObject * obj0 = 0 ;
5465 PyObject * obj1 = 0 ;
5466 char * kwnames[] = {
5467 (char *) "x",(char *) "y", NULL
5468 };
5469
5470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5471 if (obj0) {
5472 ecode1 = SWIG_AsVal_double(obj0, &val1);
5473 if (!SWIG_IsOK(ecode1)) {
5474 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5475 }
5476 arg1 = static_cast< double >(val1);
5477 }
5478 if (obj1) {
5479 ecode2 = SWIG_AsVal_double(obj1, &val2);
5480 if (!SWIG_IsOK(ecode2)) {
5481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5482 }
5483 arg2 = static_cast< double >(val2);
5484 }
5485 {
5486 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5487 if (PyErr_Occurred()) SWIG_fail;
5488 }
5489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5490 return resultobj;
5491 fail:
5492 return NULL;
5493 }
5494
5495
5496 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5497 PyObject *resultobj = 0;
5498 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5499 void *argp1 = 0 ;
5500 int res1 = 0 ;
5501 PyObject *swig_obj[1] ;
5502
5503 if (!args) SWIG_fail;
5504 swig_obj[0] = args;
5505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5506 if (!SWIG_IsOK(res1)) {
5507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5508 }
5509 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5510 {
5511 delete arg1;
5512
5513 if (PyErr_Occurred()) SWIG_fail;
5514 }
5515 resultobj = SWIG_Py_Void();
5516 return resultobj;
5517 fail:
5518 return NULL;
5519 }
5520
5521
5522 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5523 PyObject *resultobj = 0;
5524 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5525 PyObject *arg2 = (PyObject *) 0 ;
5526 bool result;
5527 void *argp1 = 0 ;
5528 int res1 = 0 ;
5529 PyObject * obj0 = 0 ;
5530 PyObject * obj1 = 0 ;
5531 char * kwnames[] = {
5532 (char *) "self",(char *) "other", NULL
5533 };
5534
5535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5537 if (!SWIG_IsOK(res1)) {
5538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5539 }
5540 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5541 arg2 = obj1;
5542 {
5543 result = (bool)wxRealPoint___eq__(arg1,arg2);
5544 if (PyErr_Occurred()) SWIG_fail;
5545 }
5546 {
5547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5548 }
5549 return resultobj;
5550 fail:
5551 return NULL;
5552 }
5553
5554
5555 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5556 PyObject *resultobj = 0;
5557 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5558 PyObject *arg2 = (PyObject *) 0 ;
5559 bool result;
5560 void *argp1 = 0 ;
5561 int res1 = 0 ;
5562 PyObject * obj0 = 0 ;
5563 PyObject * obj1 = 0 ;
5564 char * kwnames[] = {
5565 (char *) "self",(char *) "other", NULL
5566 };
5567
5568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5570 if (!SWIG_IsOK(res1)) {
5571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5572 }
5573 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5574 arg2 = obj1;
5575 {
5576 result = (bool)wxRealPoint___ne__(arg1,arg2);
5577 if (PyErr_Occurred()) SWIG_fail;
5578 }
5579 {
5580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5581 }
5582 return resultobj;
5583 fail:
5584 return NULL;
5585 }
5586
5587
5588 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5589 PyObject *resultobj = 0;
5590 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5591 wxRealPoint *arg2 = 0 ;
5592 wxRealPoint result;
5593 void *argp1 = 0 ;
5594 int res1 = 0 ;
5595 wxRealPoint temp2 ;
5596 PyObject * obj0 = 0 ;
5597 PyObject * obj1 = 0 ;
5598 char * kwnames[] = {
5599 (char *) "self",(char *) "pt", NULL
5600 };
5601
5602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5604 if (!SWIG_IsOK(res1)) {
5605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5606 }
5607 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5608 {
5609 arg2 = &temp2;
5610 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5611 }
5612 {
5613 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5614 if (PyErr_Occurred()) SWIG_fail;
5615 }
5616 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5617 return resultobj;
5618 fail:
5619 return NULL;
5620 }
5621
5622
5623 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5624 PyObject *resultobj = 0;
5625 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5626 wxRealPoint *arg2 = 0 ;
5627 wxRealPoint result;
5628 void *argp1 = 0 ;
5629 int res1 = 0 ;
5630 wxRealPoint temp2 ;
5631 PyObject * obj0 = 0 ;
5632 PyObject * obj1 = 0 ;
5633 char * kwnames[] = {
5634 (char *) "self",(char *) "pt", NULL
5635 };
5636
5637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5639 if (!SWIG_IsOK(res1)) {
5640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5641 }
5642 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5643 {
5644 arg2 = &temp2;
5645 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5646 }
5647 {
5648 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5649 if (PyErr_Occurred()) SWIG_fail;
5650 }
5651 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5652 return resultobj;
5653 fail:
5654 return NULL;
5655 }
5656
5657
5658 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5659 PyObject *resultobj = 0;
5660 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5661 double arg2 ;
5662 double arg3 ;
5663 void *argp1 = 0 ;
5664 int res1 = 0 ;
5665 double val2 ;
5666 int ecode2 = 0 ;
5667 double val3 ;
5668 int ecode3 = 0 ;
5669 PyObject * obj0 = 0 ;
5670 PyObject * obj1 = 0 ;
5671 PyObject * obj2 = 0 ;
5672 char * kwnames[] = {
5673 (char *) "self",(char *) "x",(char *) "y", NULL
5674 };
5675
5676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5678 if (!SWIG_IsOK(res1)) {
5679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5680 }
5681 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5682 ecode2 = SWIG_AsVal_double(obj1, &val2);
5683 if (!SWIG_IsOK(ecode2)) {
5684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5685 }
5686 arg2 = static_cast< double >(val2);
5687 ecode3 = SWIG_AsVal_double(obj2, &val3);
5688 if (!SWIG_IsOK(ecode3)) {
5689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5690 }
5691 arg3 = static_cast< double >(val3);
5692 {
5693 wxRealPoint_Set(arg1,arg2,arg3);
5694 if (PyErr_Occurred()) SWIG_fail;
5695 }
5696 resultobj = SWIG_Py_Void();
5697 return resultobj;
5698 fail:
5699 return NULL;
5700 }
5701
5702
5703 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5704 PyObject *resultobj = 0;
5705 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5706 PyObject *result = 0 ;
5707 void *argp1 = 0 ;
5708 int res1 = 0 ;
5709 PyObject *swig_obj[1] ;
5710
5711 if (!args) SWIG_fail;
5712 swig_obj[0] = args;
5713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5714 if (!SWIG_IsOK(res1)) {
5715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5716 }
5717 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5718 {
5719 result = (PyObject *)wxRealPoint_Get(arg1);
5720 if (PyErr_Occurred()) SWIG_fail;
5721 }
5722 resultobj = result;
5723 return resultobj;
5724 fail:
5725 return NULL;
5726 }
5727
5728
5729 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5730 PyObject *obj;
5731 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5732 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5733 return SWIG_Py_Void();
5734 }
5735
5736 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5737 return SWIG_Python_InitShadowInstance(args);
5738 }
5739
5740 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5741 PyObject *resultobj = 0;
5742 wxPoint *arg1 = (wxPoint *) 0 ;
5743 int arg2 ;
5744 void *argp1 = 0 ;
5745 int res1 = 0 ;
5746 int val2 ;
5747 int ecode2 = 0 ;
5748 PyObject *swig_obj[2] ;
5749
5750 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5752 if (!SWIG_IsOK(res1)) {
5753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5754 }
5755 arg1 = reinterpret_cast< wxPoint * >(argp1);
5756 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5757 if (!SWIG_IsOK(ecode2)) {
5758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5759 }
5760 arg2 = static_cast< int >(val2);
5761 if (arg1) (arg1)->x = arg2;
5762
5763 resultobj = SWIG_Py_Void();
5764 return resultobj;
5765 fail:
5766 return NULL;
5767 }
5768
5769
5770 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5771 PyObject *resultobj = 0;
5772 wxPoint *arg1 = (wxPoint *) 0 ;
5773 int result;
5774 void *argp1 = 0 ;
5775 int res1 = 0 ;
5776 PyObject *swig_obj[1] ;
5777
5778 if (!args) SWIG_fail;
5779 swig_obj[0] = args;
5780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5781 if (!SWIG_IsOK(res1)) {
5782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5783 }
5784 arg1 = reinterpret_cast< wxPoint * >(argp1);
5785 result = (int) ((arg1)->x);
5786 resultobj = SWIG_From_int(static_cast< int >(result));
5787 return resultobj;
5788 fail:
5789 return NULL;
5790 }
5791
5792
5793 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5794 PyObject *resultobj = 0;
5795 wxPoint *arg1 = (wxPoint *) 0 ;
5796 int arg2 ;
5797 void *argp1 = 0 ;
5798 int res1 = 0 ;
5799 int val2 ;
5800 int ecode2 = 0 ;
5801 PyObject *swig_obj[2] ;
5802
5803 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5805 if (!SWIG_IsOK(res1)) {
5806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5807 }
5808 arg1 = reinterpret_cast< wxPoint * >(argp1);
5809 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5810 if (!SWIG_IsOK(ecode2)) {
5811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5812 }
5813 arg2 = static_cast< int >(val2);
5814 if (arg1) (arg1)->y = arg2;
5815
5816 resultobj = SWIG_Py_Void();
5817 return resultobj;
5818 fail:
5819 return NULL;
5820 }
5821
5822
5823 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5824 PyObject *resultobj = 0;
5825 wxPoint *arg1 = (wxPoint *) 0 ;
5826 int result;
5827 void *argp1 = 0 ;
5828 int res1 = 0 ;
5829 PyObject *swig_obj[1] ;
5830
5831 if (!args) SWIG_fail;
5832 swig_obj[0] = args;
5833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5834 if (!SWIG_IsOK(res1)) {
5835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5836 }
5837 arg1 = reinterpret_cast< wxPoint * >(argp1);
5838 result = (int) ((arg1)->y);
5839 resultobj = SWIG_From_int(static_cast< int >(result));
5840 return resultobj;
5841 fail:
5842 return NULL;
5843 }
5844
5845
5846 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5847 PyObject *resultobj = 0;
5848 int arg1 = (int) 0 ;
5849 int arg2 = (int) 0 ;
5850 wxPoint *result = 0 ;
5851 int val1 ;
5852 int ecode1 = 0 ;
5853 int val2 ;
5854 int ecode2 = 0 ;
5855 PyObject * obj0 = 0 ;
5856 PyObject * obj1 = 0 ;
5857 char * kwnames[] = {
5858 (char *) "x",(char *) "y", NULL
5859 };
5860
5861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5862 if (obj0) {
5863 ecode1 = SWIG_AsVal_int(obj0, &val1);
5864 if (!SWIG_IsOK(ecode1)) {
5865 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5866 }
5867 arg1 = static_cast< int >(val1);
5868 }
5869 if (obj1) {
5870 ecode2 = SWIG_AsVal_int(obj1, &val2);
5871 if (!SWIG_IsOK(ecode2)) {
5872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5873 }
5874 arg2 = static_cast< int >(val2);
5875 }
5876 {
5877 result = (wxPoint *)new wxPoint(arg1,arg2);
5878 if (PyErr_Occurred()) SWIG_fail;
5879 }
5880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5881 return resultobj;
5882 fail:
5883 return NULL;
5884 }
5885
5886
5887 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5888 PyObject *resultobj = 0;
5889 wxPoint *arg1 = (wxPoint *) 0 ;
5890 void *argp1 = 0 ;
5891 int res1 = 0 ;
5892 PyObject *swig_obj[1] ;
5893
5894 if (!args) SWIG_fail;
5895 swig_obj[0] = args;
5896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5897 if (!SWIG_IsOK(res1)) {
5898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5899 }
5900 arg1 = reinterpret_cast< wxPoint * >(argp1);
5901 {
5902 delete arg1;
5903
5904 if (PyErr_Occurred()) SWIG_fail;
5905 }
5906 resultobj = SWIG_Py_Void();
5907 return resultobj;
5908 fail:
5909 return NULL;
5910 }
5911
5912
5913 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5914 PyObject *resultobj = 0;
5915 wxPoint *arg1 = (wxPoint *) 0 ;
5916 PyObject *arg2 = (PyObject *) 0 ;
5917 bool result;
5918 void *argp1 = 0 ;
5919 int res1 = 0 ;
5920 PyObject * obj0 = 0 ;
5921 PyObject * obj1 = 0 ;
5922 char * kwnames[] = {
5923 (char *) "self",(char *) "other", NULL
5924 };
5925
5926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5928 if (!SWIG_IsOK(res1)) {
5929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5930 }
5931 arg1 = reinterpret_cast< wxPoint * >(argp1);
5932 arg2 = obj1;
5933 {
5934 result = (bool)wxPoint___eq__(arg1,arg2);
5935 if (PyErr_Occurred()) SWIG_fail;
5936 }
5937 {
5938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5939 }
5940 return resultobj;
5941 fail:
5942 return NULL;
5943 }
5944
5945
5946 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5947 PyObject *resultobj = 0;
5948 wxPoint *arg1 = (wxPoint *) 0 ;
5949 PyObject *arg2 = (PyObject *) 0 ;
5950 bool result;
5951 void *argp1 = 0 ;
5952 int res1 = 0 ;
5953 PyObject * obj0 = 0 ;
5954 PyObject * obj1 = 0 ;
5955 char * kwnames[] = {
5956 (char *) "self",(char *) "other", NULL
5957 };
5958
5959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5961 if (!SWIG_IsOK(res1)) {
5962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5963 }
5964 arg1 = reinterpret_cast< wxPoint * >(argp1);
5965 arg2 = obj1;
5966 {
5967 result = (bool)wxPoint___ne__(arg1,arg2);
5968 if (PyErr_Occurred()) SWIG_fail;
5969 }
5970 {
5971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5972 }
5973 return resultobj;
5974 fail:
5975 return NULL;
5976 }
5977
5978
5979 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5980 PyObject *resultobj = 0;
5981 wxPoint *arg1 = (wxPoint *) 0 ;
5982 wxPoint *arg2 = 0 ;
5983 wxPoint result;
5984 void *argp1 = 0 ;
5985 int res1 = 0 ;
5986 wxPoint temp2 ;
5987 PyObject * obj0 = 0 ;
5988 PyObject * obj1 = 0 ;
5989 char * kwnames[] = {
5990 (char *) "self",(char *) "pt", NULL
5991 };
5992
5993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5995 if (!SWIG_IsOK(res1)) {
5996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5997 }
5998 arg1 = reinterpret_cast< wxPoint * >(argp1);
5999 {
6000 arg2 = &temp2;
6001 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6002 }
6003 {
6004 result = (arg1)->operator +((wxPoint const &)*arg2);
6005 if (PyErr_Occurred()) SWIG_fail;
6006 }
6007 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6008 return resultobj;
6009 fail:
6010 return NULL;
6011 }
6012
6013
6014 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6015 PyObject *resultobj = 0;
6016 wxPoint *arg1 = (wxPoint *) 0 ;
6017 wxPoint *arg2 = 0 ;
6018 wxPoint result;
6019 void *argp1 = 0 ;
6020 int res1 = 0 ;
6021 wxPoint temp2 ;
6022 PyObject * obj0 = 0 ;
6023 PyObject * obj1 = 0 ;
6024 char * kwnames[] = {
6025 (char *) "self",(char *) "pt", NULL
6026 };
6027
6028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6030 if (!SWIG_IsOK(res1)) {
6031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6032 }
6033 arg1 = reinterpret_cast< wxPoint * >(argp1);
6034 {
6035 arg2 = &temp2;
6036 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6037 }
6038 {
6039 result = (arg1)->operator -((wxPoint const &)*arg2);
6040 if (PyErr_Occurred()) SWIG_fail;
6041 }
6042 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6043 return resultobj;
6044 fail:
6045 return NULL;
6046 }
6047
6048
6049 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6050 PyObject *resultobj = 0;
6051 wxPoint *arg1 = (wxPoint *) 0 ;
6052 wxPoint *arg2 = 0 ;
6053 wxPoint *result = 0 ;
6054 void *argp1 = 0 ;
6055 int res1 = 0 ;
6056 wxPoint temp2 ;
6057 PyObject * obj0 = 0 ;
6058 PyObject * obj1 = 0 ;
6059 char * kwnames[] = {
6060 (char *) "self",(char *) "pt", NULL
6061 };
6062
6063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6065 if (!SWIG_IsOK(res1)) {
6066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6067 }
6068 arg1 = reinterpret_cast< wxPoint * >(argp1);
6069 {
6070 arg2 = &temp2;
6071 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6072 }
6073 {
6074 {
6075 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6076 result = (wxPoint *) &_result_ref;
6077 }
6078 if (PyErr_Occurred()) SWIG_fail;
6079 }
6080 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6081 return resultobj;
6082 fail:
6083 return NULL;
6084 }
6085
6086
6087 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6088 PyObject *resultobj = 0;
6089 wxPoint *arg1 = (wxPoint *) 0 ;
6090 wxPoint *arg2 = 0 ;
6091 wxPoint *result = 0 ;
6092 void *argp1 = 0 ;
6093 int res1 = 0 ;
6094 wxPoint temp2 ;
6095 PyObject * obj0 = 0 ;
6096 PyObject * obj1 = 0 ;
6097 char * kwnames[] = {
6098 (char *) "self",(char *) "pt", NULL
6099 };
6100
6101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6103 if (!SWIG_IsOK(res1)) {
6104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6105 }
6106 arg1 = reinterpret_cast< wxPoint * >(argp1);
6107 {
6108 arg2 = &temp2;
6109 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6110 }
6111 {
6112 {
6113 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6114 result = (wxPoint *) &_result_ref;
6115 }
6116 if (PyErr_Occurred()) SWIG_fail;
6117 }
6118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6119 return resultobj;
6120 fail:
6121 return NULL;
6122 }
6123
6124
6125 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6126 PyObject *resultobj = 0;
6127 wxPoint *arg1 = (wxPoint *) 0 ;
6128 long arg2 ;
6129 long arg3 ;
6130 void *argp1 = 0 ;
6131 int res1 = 0 ;
6132 long val2 ;
6133 int ecode2 = 0 ;
6134 long val3 ;
6135 int ecode3 = 0 ;
6136 PyObject * obj0 = 0 ;
6137 PyObject * obj1 = 0 ;
6138 PyObject * obj2 = 0 ;
6139 char * kwnames[] = {
6140 (char *) "self",(char *) "x",(char *) "y", NULL
6141 };
6142
6143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6145 if (!SWIG_IsOK(res1)) {
6146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6147 }
6148 arg1 = reinterpret_cast< wxPoint * >(argp1);
6149 ecode2 = SWIG_AsVal_long(obj1, &val2);
6150 if (!SWIG_IsOK(ecode2)) {
6151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6152 }
6153 arg2 = static_cast< long >(val2);
6154 ecode3 = SWIG_AsVal_long(obj2, &val3);
6155 if (!SWIG_IsOK(ecode3)) {
6156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6157 }
6158 arg3 = static_cast< long >(val3);
6159 {
6160 wxPoint_Set(arg1,arg2,arg3);
6161 if (PyErr_Occurred()) SWIG_fail;
6162 }
6163 resultobj = SWIG_Py_Void();
6164 return resultobj;
6165 fail:
6166 return NULL;
6167 }
6168
6169
6170 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6171 PyObject *resultobj = 0;
6172 wxPoint *arg1 = (wxPoint *) 0 ;
6173 PyObject *result = 0 ;
6174 void *argp1 = 0 ;
6175 int res1 = 0 ;
6176 PyObject *swig_obj[1] ;
6177
6178 if (!args) SWIG_fail;
6179 swig_obj[0] = args;
6180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6181 if (!SWIG_IsOK(res1)) {
6182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6183 }
6184 arg1 = reinterpret_cast< wxPoint * >(argp1);
6185 {
6186 result = (PyObject *)wxPoint_Get(arg1);
6187 if (PyErr_Occurred()) SWIG_fail;
6188 }
6189 resultobj = result;
6190 return resultobj;
6191 fail:
6192 return NULL;
6193 }
6194
6195
6196 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6197 PyObject *obj;
6198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6199 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6200 return SWIG_Py_Void();
6201 }
6202
6203 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6204 return SWIG_Python_InitShadowInstance(args);
6205 }
6206
6207 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6208 PyObject *resultobj = 0;
6209 int arg1 = (int) 0 ;
6210 int arg2 = (int) 0 ;
6211 int arg3 = (int) 0 ;
6212 int arg4 = (int) 0 ;
6213 wxRect *result = 0 ;
6214 int val1 ;
6215 int ecode1 = 0 ;
6216 int val2 ;
6217 int ecode2 = 0 ;
6218 int val3 ;
6219 int ecode3 = 0 ;
6220 int val4 ;
6221 int ecode4 = 0 ;
6222 PyObject * obj0 = 0 ;
6223 PyObject * obj1 = 0 ;
6224 PyObject * obj2 = 0 ;
6225 PyObject * obj3 = 0 ;
6226 char * kwnames[] = {
6227 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6228 };
6229
6230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6231 if (obj0) {
6232 ecode1 = SWIG_AsVal_int(obj0, &val1);
6233 if (!SWIG_IsOK(ecode1)) {
6234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6235 }
6236 arg1 = static_cast< int >(val1);
6237 }
6238 if (obj1) {
6239 ecode2 = SWIG_AsVal_int(obj1, &val2);
6240 if (!SWIG_IsOK(ecode2)) {
6241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6242 }
6243 arg2 = static_cast< int >(val2);
6244 }
6245 if (obj2) {
6246 ecode3 = SWIG_AsVal_int(obj2, &val3);
6247 if (!SWIG_IsOK(ecode3)) {
6248 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6249 }
6250 arg3 = static_cast< int >(val3);
6251 }
6252 if (obj3) {
6253 ecode4 = SWIG_AsVal_int(obj3, &val4);
6254 if (!SWIG_IsOK(ecode4)) {
6255 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6256 }
6257 arg4 = static_cast< int >(val4);
6258 }
6259 {
6260 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6261 if (PyErr_Occurred()) SWIG_fail;
6262 }
6263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6264 return resultobj;
6265 fail:
6266 return NULL;
6267 }
6268
6269
6270 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6271 PyObject *resultobj = 0;
6272 wxPoint *arg1 = 0 ;
6273 wxPoint *arg2 = 0 ;
6274 wxRect *result = 0 ;
6275 wxPoint temp1 ;
6276 wxPoint temp2 ;
6277 PyObject * obj0 = 0 ;
6278 PyObject * obj1 = 0 ;
6279 char * kwnames[] = {
6280 (char *) "topLeft",(char *) "bottomRight", NULL
6281 };
6282
6283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6284 {
6285 arg1 = &temp1;
6286 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6287 }
6288 {
6289 arg2 = &temp2;
6290 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6291 }
6292 {
6293 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6294 if (PyErr_Occurred()) SWIG_fail;
6295 }
6296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6297 return resultobj;
6298 fail:
6299 return NULL;
6300 }
6301
6302
6303 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6304 PyObject *resultobj = 0;
6305 wxPoint *arg1 = 0 ;
6306 wxSize *arg2 = 0 ;
6307 wxRect *result = 0 ;
6308 wxPoint temp1 ;
6309 wxSize temp2 ;
6310 PyObject * obj0 = 0 ;
6311 PyObject * obj1 = 0 ;
6312 char * kwnames[] = {
6313 (char *) "pos",(char *) "size", NULL
6314 };
6315
6316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6317 {
6318 arg1 = &temp1;
6319 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6320 }
6321 {
6322 arg2 = &temp2;
6323 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6324 }
6325 {
6326 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6327 if (PyErr_Occurred()) SWIG_fail;
6328 }
6329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6330 return resultobj;
6331 fail:
6332 return NULL;
6333 }
6334
6335
6336 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6337 PyObject *resultobj = 0;
6338 wxSize *arg1 = 0 ;
6339 wxRect *result = 0 ;
6340 wxSize temp1 ;
6341 PyObject * obj0 = 0 ;
6342 char * kwnames[] = {
6343 (char *) "size", NULL
6344 };
6345
6346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6347 {
6348 arg1 = &temp1;
6349 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6350 }
6351 {
6352 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6353 if (PyErr_Occurred()) SWIG_fail;
6354 }
6355 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6356 return resultobj;
6357 fail:
6358 return NULL;
6359 }
6360
6361
6362 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6363 PyObject *resultobj = 0;
6364 wxRect *arg1 = (wxRect *) 0 ;
6365 void *argp1 = 0 ;
6366 int res1 = 0 ;
6367 PyObject *swig_obj[1] ;
6368
6369 if (!args) SWIG_fail;
6370 swig_obj[0] = args;
6371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6372 if (!SWIG_IsOK(res1)) {
6373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6374 }
6375 arg1 = reinterpret_cast< wxRect * >(argp1);
6376 {
6377 delete arg1;
6378
6379 if (PyErr_Occurred()) SWIG_fail;
6380 }
6381 resultobj = SWIG_Py_Void();
6382 return resultobj;
6383 fail:
6384 return NULL;
6385 }
6386
6387
6388 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6389 PyObject *resultobj = 0;
6390 wxRect *arg1 = (wxRect *) 0 ;
6391 int result;
6392 void *argp1 = 0 ;
6393 int res1 = 0 ;
6394 PyObject *swig_obj[1] ;
6395
6396 if (!args) SWIG_fail;
6397 swig_obj[0] = args;
6398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6399 if (!SWIG_IsOK(res1)) {
6400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6401 }
6402 arg1 = reinterpret_cast< wxRect * >(argp1);
6403 {
6404 result = (int)((wxRect const *)arg1)->GetX();
6405 if (PyErr_Occurred()) SWIG_fail;
6406 }
6407 resultobj = SWIG_From_int(static_cast< int >(result));
6408 return resultobj;
6409 fail:
6410 return NULL;
6411 }
6412
6413
6414 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6415 PyObject *resultobj = 0;
6416 wxRect *arg1 = (wxRect *) 0 ;
6417 int arg2 ;
6418 void *argp1 = 0 ;
6419 int res1 = 0 ;
6420 int val2 ;
6421 int ecode2 = 0 ;
6422 PyObject * obj0 = 0 ;
6423 PyObject * obj1 = 0 ;
6424 char * kwnames[] = {
6425 (char *) "self",(char *) "x", NULL
6426 };
6427
6428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6430 if (!SWIG_IsOK(res1)) {
6431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6432 }
6433 arg1 = reinterpret_cast< wxRect * >(argp1);
6434 ecode2 = SWIG_AsVal_int(obj1, &val2);
6435 if (!SWIG_IsOK(ecode2)) {
6436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6437 }
6438 arg2 = static_cast< int >(val2);
6439 {
6440 (arg1)->SetX(arg2);
6441 if (PyErr_Occurred()) SWIG_fail;
6442 }
6443 resultobj = SWIG_Py_Void();
6444 return resultobj;
6445 fail:
6446 return NULL;
6447 }
6448
6449
6450 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6451 PyObject *resultobj = 0;
6452 wxRect *arg1 = (wxRect *) 0 ;
6453 int result;
6454 void *argp1 = 0 ;
6455 int res1 = 0 ;
6456 PyObject *swig_obj[1] ;
6457
6458 if (!args) SWIG_fail;
6459 swig_obj[0] = args;
6460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6461 if (!SWIG_IsOK(res1)) {
6462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6463 }
6464 arg1 = reinterpret_cast< wxRect * >(argp1);
6465 {
6466 result = (int)(arg1)->GetY();
6467 if (PyErr_Occurred()) SWIG_fail;
6468 }
6469 resultobj = SWIG_From_int(static_cast< int >(result));
6470 return resultobj;
6471 fail:
6472 return NULL;
6473 }
6474
6475
6476 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6477 PyObject *resultobj = 0;
6478 wxRect *arg1 = (wxRect *) 0 ;
6479 int arg2 ;
6480 void *argp1 = 0 ;
6481 int res1 = 0 ;
6482 int val2 ;
6483 int ecode2 = 0 ;
6484 PyObject * obj0 = 0 ;
6485 PyObject * obj1 = 0 ;
6486 char * kwnames[] = {
6487 (char *) "self",(char *) "y", NULL
6488 };
6489
6490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6492 if (!SWIG_IsOK(res1)) {
6493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6494 }
6495 arg1 = reinterpret_cast< wxRect * >(argp1);
6496 ecode2 = SWIG_AsVal_int(obj1, &val2);
6497 if (!SWIG_IsOK(ecode2)) {
6498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6499 }
6500 arg2 = static_cast< int >(val2);
6501 {
6502 (arg1)->SetY(arg2);
6503 if (PyErr_Occurred()) SWIG_fail;
6504 }
6505 resultobj = SWIG_Py_Void();
6506 return resultobj;
6507 fail:
6508 return NULL;
6509 }
6510
6511
6512 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6513 PyObject *resultobj = 0;
6514 wxRect *arg1 = (wxRect *) 0 ;
6515 int result;
6516 void *argp1 = 0 ;
6517 int res1 = 0 ;
6518 PyObject *swig_obj[1] ;
6519
6520 if (!args) SWIG_fail;
6521 swig_obj[0] = args;
6522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6523 if (!SWIG_IsOK(res1)) {
6524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6525 }
6526 arg1 = reinterpret_cast< wxRect * >(argp1);
6527 {
6528 result = (int)((wxRect const *)arg1)->GetWidth();
6529 if (PyErr_Occurred()) SWIG_fail;
6530 }
6531 resultobj = SWIG_From_int(static_cast< int >(result));
6532 return resultobj;
6533 fail:
6534 return NULL;
6535 }
6536
6537
6538 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6539 PyObject *resultobj = 0;
6540 wxRect *arg1 = (wxRect *) 0 ;
6541 int arg2 ;
6542 void *argp1 = 0 ;
6543 int res1 = 0 ;
6544 int val2 ;
6545 int ecode2 = 0 ;
6546 PyObject * obj0 = 0 ;
6547 PyObject * obj1 = 0 ;
6548 char * kwnames[] = {
6549 (char *) "self",(char *) "w", NULL
6550 };
6551
6552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6554 if (!SWIG_IsOK(res1)) {
6555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6556 }
6557 arg1 = reinterpret_cast< wxRect * >(argp1);
6558 ecode2 = SWIG_AsVal_int(obj1, &val2);
6559 if (!SWIG_IsOK(ecode2)) {
6560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6561 }
6562 arg2 = static_cast< int >(val2);
6563 {
6564 (arg1)->SetWidth(arg2);
6565 if (PyErr_Occurred()) SWIG_fail;
6566 }
6567 resultobj = SWIG_Py_Void();
6568 return resultobj;
6569 fail:
6570 return NULL;
6571 }
6572
6573
6574 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6575 PyObject *resultobj = 0;
6576 wxRect *arg1 = (wxRect *) 0 ;
6577 int result;
6578 void *argp1 = 0 ;
6579 int res1 = 0 ;
6580 PyObject *swig_obj[1] ;
6581
6582 if (!args) SWIG_fail;
6583 swig_obj[0] = args;
6584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6585 if (!SWIG_IsOK(res1)) {
6586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6587 }
6588 arg1 = reinterpret_cast< wxRect * >(argp1);
6589 {
6590 result = (int)((wxRect const *)arg1)->GetHeight();
6591 if (PyErr_Occurred()) SWIG_fail;
6592 }
6593 resultobj = SWIG_From_int(static_cast< int >(result));
6594 return resultobj;
6595 fail:
6596 return NULL;
6597 }
6598
6599
6600 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6601 PyObject *resultobj = 0;
6602 wxRect *arg1 = (wxRect *) 0 ;
6603 int arg2 ;
6604 void *argp1 = 0 ;
6605 int res1 = 0 ;
6606 int val2 ;
6607 int ecode2 = 0 ;
6608 PyObject * obj0 = 0 ;
6609 PyObject * obj1 = 0 ;
6610 char * kwnames[] = {
6611 (char *) "self",(char *) "h", NULL
6612 };
6613
6614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6616 if (!SWIG_IsOK(res1)) {
6617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6618 }
6619 arg1 = reinterpret_cast< wxRect * >(argp1);
6620 ecode2 = SWIG_AsVal_int(obj1, &val2);
6621 if (!SWIG_IsOK(ecode2)) {
6622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6623 }
6624 arg2 = static_cast< int >(val2);
6625 {
6626 (arg1)->SetHeight(arg2);
6627 if (PyErr_Occurred()) SWIG_fail;
6628 }
6629 resultobj = SWIG_Py_Void();
6630 return resultobj;
6631 fail:
6632 return NULL;
6633 }
6634
6635
6636 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6637 PyObject *resultobj = 0;
6638 wxRect *arg1 = (wxRect *) 0 ;
6639 wxPoint result;
6640 void *argp1 = 0 ;
6641 int res1 = 0 ;
6642 PyObject *swig_obj[1] ;
6643
6644 if (!args) SWIG_fail;
6645 swig_obj[0] = args;
6646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6647 if (!SWIG_IsOK(res1)) {
6648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6649 }
6650 arg1 = reinterpret_cast< wxRect * >(argp1);
6651 {
6652 result = ((wxRect const *)arg1)->GetPosition();
6653 if (PyErr_Occurred()) SWIG_fail;
6654 }
6655 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6656 return resultobj;
6657 fail:
6658 return NULL;
6659 }
6660
6661
6662 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6663 PyObject *resultobj = 0;
6664 wxRect *arg1 = (wxRect *) 0 ;
6665 wxPoint *arg2 = 0 ;
6666 void *argp1 = 0 ;
6667 int res1 = 0 ;
6668 wxPoint temp2 ;
6669 PyObject * obj0 = 0 ;
6670 PyObject * obj1 = 0 ;
6671 char * kwnames[] = {
6672 (char *) "self",(char *) "p", NULL
6673 };
6674
6675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6677 if (!SWIG_IsOK(res1)) {
6678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6679 }
6680 arg1 = reinterpret_cast< wxRect * >(argp1);
6681 {
6682 arg2 = &temp2;
6683 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6684 }
6685 {
6686 (arg1)->SetPosition((wxPoint const &)*arg2);
6687 if (PyErr_Occurred()) SWIG_fail;
6688 }
6689 resultobj = SWIG_Py_Void();
6690 return resultobj;
6691 fail:
6692 return NULL;
6693 }
6694
6695
6696 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6697 PyObject *resultobj = 0;
6698 wxRect *arg1 = (wxRect *) 0 ;
6699 wxSize result;
6700 void *argp1 = 0 ;
6701 int res1 = 0 ;
6702 PyObject *swig_obj[1] ;
6703
6704 if (!args) SWIG_fail;
6705 swig_obj[0] = args;
6706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6707 if (!SWIG_IsOK(res1)) {
6708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6709 }
6710 arg1 = reinterpret_cast< wxRect * >(argp1);
6711 {
6712 result = ((wxRect const *)arg1)->GetSize();
6713 if (PyErr_Occurred()) SWIG_fail;
6714 }
6715 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6716 return resultobj;
6717 fail:
6718 return NULL;
6719 }
6720
6721
6722 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6723 PyObject *resultobj = 0;
6724 wxRect *arg1 = (wxRect *) 0 ;
6725 wxSize *arg2 = 0 ;
6726 void *argp1 = 0 ;
6727 int res1 = 0 ;
6728 wxSize temp2 ;
6729 PyObject * obj0 = 0 ;
6730 PyObject * obj1 = 0 ;
6731 char * kwnames[] = {
6732 (char *) "self",(char *) "s", NULL
6733 };
6734
6735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6737 if (!SWIG_IsOK(res1)) {
6738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6739 }
6740 arg1 = reinterpret_cast< wxRect * >(argp1);
6741 {
6742 arg2 = &temp2;
6743 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6744 }
6745 {
6746 (arg1)->SetSize((wxSize const &)*arg2);
6747 if (PyErr_Occurred()) SWIG_fail;
6748 }
6749 resultobj = SWIG_Py_Void();
6750 return resultobj;
6751 fail:
6752 return NULL;
6753 }
6754
6755
6756 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6757 PyObject *resultobj = 0;
6758 wxRect *arg1 = (wxRect *) 0 ;
6759 bool result;
6760 void *argp1 = 0 ;
6761 int res1 = 0 ;
6762 PyObject *swig_obj[1] ;
6763
6764 if (!args) SWIG_fail;
6765 swig_obj[0] = args;
6766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6767 if (!SWIG_IsOK(res1)) {
6768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6769 }
6770 arg1 = reinterpret_cast< wxRect * >(argp1);
6771 {
6772 result = (bool)((wxRect const *)arg1)->IsEmpty();
6773 if (PyErr_Occurred()) SWIG_fail;
6774 }
6775 {
6776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6777 }
6778 return resultobj;
6779 fail:
6780 return NULL;
6781 }
6782
6783
6784 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6785 PyObject *resultobj = 0;
6786 wxRect *arg1 = (wxRect *) 0 ;
6787 wxPoint result;
6788 void *argp1 = 0 ;
6789 int res1 = 0 ;
6790 PyObject *swig_obj[1] ;
6791
6792 if (!args) SWIG_fail;
6793 swig_obj[0] = args;
6794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6795 if (!SWIG_IsOK(res1)) {
6796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6797 }
6798 arg1 = reinterpret_cast< wxRect * >(argp1);
6799 {
6800 result = ((wxRect const *)arg1)->GetTopLeft();
6801 if (PyErr_Occurred()) SWIG_fail;
6802 }
6803 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6804 return resultobj;
6805 fail:
6806 return NULL;
6807 }
6808
6809
6810 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6811 PyObject *resultobj = 0;
6812 wxRect *arg1 = (wxRect *) 0 ;
6813 wxPoint *arg2 = 0 ;
6814 void *argp1 = 0 ;
6815 int res1 = 0 ;
6816 wxPoint temp2 ;
6817 PyObject * obj0 = 0 ;
6818 PyObject * obj1 = 0 ;
6819 char * kwnames[] = {
6820 (char *) "self",(char *) "p", NULL
6821 };
6822
6823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",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_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6827 }
6828 arg1 = reinterpret_cast< wxRect * >(argp1);
6829 {
6830 arg2 = &temp2;
6831 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6832 }
6833 {
6834 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6835 if (PyErr_Occurred()) SWIG_fail;
6836 }
6837 resultobj = SWIG_Py_Void();
6838 return resultobj;
6839 fail:
6840 return NULL;
6841 }
6842
6843
6844 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6845 PyObject *resultobj = 0;
6846 wxRect *arg1 = (wxRect *) 0 ;
6847 wxPoint result;
6848 void *argp1 = 0 ;
6849 int res1 = 0 ;
6850 PyObject *swig_obj[1] ;
6851
6852 if (!args) SWIG_fail;
6853 swig_obj[0] = args;
6854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6855 if (!SWIG_IsOK(res1)) {
6856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6857 }
6858 arg1 = reinterpret_cast< wxRect * >(argp1);
6859 {
6860 result = ((wxRect const *)arg1)->GetBottomRight();
6861 if (PyErr_Occurred()) SWIG_fail;
6862 }
6863 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6864 return resultobj;
6865 fail:
6866 return NULL;
6867 }
6868
6869
6870 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6871 PyObject *resultobj = 0;
6872 wxRect *arg1 = (wxRect *) 0 ;
6873 wxPoint *arg2 = 0 ;
6874 void *argp1 = 0 ;
6875 int res1 = 0 ;
6876 wxPoint temp2 ;
6877 PyObject * obj0 = 0 ;
6878 PyObject * obj1 = 0 ;
6879 char * kwnames[] = {
6880 (char *) "self",(char *) "p", NULL
6881 };
6882
6883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6885 if (!SWIG_IsOK(res1)) {
6886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6887 }
6888 arg1 = reinterpret_cast< wxRect * >(argp1);
6889 {
6890 arg2 = &temp2;
6891 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6892 }
6893 {
6894 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6895 if (PyErr_Occurred()) SWIG_fail;
6896 }
6897 resultobj = SWIG_Py_Void();
6898 return resultobj;
6899 fail:
6900 return NULL;
6901 }
6902
6903
6904 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6905 PyObject *resultobj = 0;
6906 wxRect *arg1 = (wxRect *) 0 ;
6907 wxPoint result;
6908 void *argp1 = 0 ;
6909 int res1 = 0 ;
6910 PyObject *swig_obj[1] ;
6911
6912 if (!args) SWIG_fail;
6913 swig_obj[0] = args;
6914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6915 if (!SWIG_IsOK(res1)) {
6916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6917 }
6918 arg1 = reinterpret_cast< wxRect * >(argp1);
6919 {
6920 result = ((wxRect const *)arg1)->GetTopRight();
6921 if (PyErr_Occurred()) SWIG_fail;
6922 }
6923 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6924 return resultobj;
6925 fail:
6926 return NULL;
6927 }
6928
6929
6930 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6931 PyObject *resultobj = 0;
6932 wxRect *arg1 = (wxRect *) 0 ;
6933 wxPoint *arg2 = 0 ;
6934 void *argp1 = 0 ;
6935 int res1 = 0 ;
6936 wxPoint temp2 ;
6937 PyObject * obj0 = 0 ;
6938 PyObject * obj1 = 0 ;
6939 char * kwnames[] = {
6940 (char *) "self",(char *) "p", NULL
6941 };
6942
6943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6945 if (!SWIG_IsOK(res1)) {
6946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6947 }
6948 arg1 = reinterpret_cast< wxRect * >(argp1);
6949 {
6950 arg2 = &temp2;
6951 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6952 }
6953 {
6954 (arg1)->SetTopRight((wxPoint const &)*arg2);
6955 if (PyErr_Occurred()) SWIG_fail;
6956 }
6957 resultobj = SWIG_Py_Void();
6958 return resultobj;
6959 fail:
6960 return NULL;
6961 }
6962
6963
6964 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6965 PyObject *resultobj = 0;
6966 wxRect *arg1 = (wxRect *) 0 ;
6967 wxPoint result;
6968 void *argp1 = 0 ;
6969 int res1 = 0 ;
6970 PyObject *swig_obj[1] ;
6971
6972 if (!args) SWIG_fail;
6973 swig_obj[0] = args;
6974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6975 if (!SWIG_IsOK(res1)) {
6976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6977 }
6978 arg1 = reinterpret_cast< wxRect * >(argp1);
6979 {
6980 result = ((wxRect const *)arg1)->GetBottomLeft();
6981 if (PyErr_Occurred()) SWIG_fail;
6982 }
6983 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6984 return resultobj;
6985 fail:
6986 return NULL;
6987 }
6988
6989
6990 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6991 PyObject *resultobj = 0;
6992 wxRect *arg1 = (wxRect *) 0 ;
6993 wxPoint *arg2 = 0 ;
6994 void *argp1 = 0 ;
6995 int res1 = 0 ;
6996 wxPoint temp2 ;
6997 PyObject * obj0 = 0 ;
6998 PyObject * obj1 = 0 ;
6999 char * kwnames[] = {
7000 (char *) "self",(char *) "p", NULL
7001 };
7002
7003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7005 if (!SWIG_IsOK(res1)) {
7006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7007 }
7008 arg1 = reinterpret_cast< wxRect * >(argp1);
7009 {
7010 arg2 = &temp2;
7011 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7012 }
7013 {
7014 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7015 if (PyErr_Occurred()) SWIG_fail;
7016 }
7017 resultobj = SWIG_Py_Void();
7018 return resultobj;
7019 fail:
7020 return NULL;
7021 }
7022
7023
7024 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7025 PyObject *resultobj = 0;
7026 wxRect *arg1 = (wxRect *) 0 ;
7027 int result;
7028 void *argp1 = 0 ;
7029 int res1 = 0 ;
7030 PyObject *swig_obj[1] ;
7031
7032 if (!args) SWIG_fail;
7033 swig_obj[0] = args;
7034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7035 if (!SWIG_IsOK(res1)) {
7036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7037 }
7038 arg1 = reinterpret_cast< wxRect * >(argp1);
7039 {
7040 result = (int)((wxRect const *)arg1)->GetLeft();
7041 if (PyErr_Occurred()) SWIG_fail;
7042 }
7043 resultobj = SWIG_From_int(static_cast< int >(result));
7044 return resultobj;
7045 fail:
7046 return NULL;
7047 }
7048
7049
7050 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7051 PyObject *resultobj = 0;
7052 wxRect *arg1 = (wxRect *) 0 ;
7053 int result;
7054 void *argp1 = 0 ;
7055 int res1 = 0 ;
7056 PyObject *swig_obj[1] ;
7057
7058 if (!args) SWIG_fail;
7059 swig_obj[0] = args;
7060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7061 if (!SWIG_IsOK(res1)) {
7062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7063 }
7064 arg1 = reinterpret_cast< wxRect * >(argp1);
7065 {
7066 result = (int)((wxRect const *)arg1)->GetTop();
7067 if (PyErr_Occurred()) SWIG_fail;
7068 }
7069 resultobj = SWIG_From_int(static_cast< int >(result));
7070 return resultobj;
7071 fail:
7072 return NULL;
7073 }
7074
7075
7076 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7077 PyObject *resultobj = 0;
7078 wxRect *arg1 = (wxRect *) 0 ;
7079 int result;
7080 void *argp1 = 0 ;
7081 int res1 = 0 ;
7082 PyObject *swig_obj[1] ;
7083
7084 if (!args) SWIG_fail;
7085 swig_obj[0] = args;
7086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7087 if (!SWIG_IsOK(res1)) {
7088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7089 }
7090 arg1 = reinterpret_cast< wxRect * >(argp1);
7091 {
7092 result = (int)((wxRect const *)arg1)->GetBottom();
7093 if (PyErr_Occurred()) SWIG_fail;
7094 }
7095 resultobj = SWIG_From_int(static_cast< int >(result));
7096 return resultobj;
7097 fail:
7098 return NULL;
7099 }
7100
7101
7102 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7103 PyObject *resultobj = 0;
7104 wxRect *arg1 = (wxRect *) 0 ;
7105 int result;
7106 void *argp1 = 0 ;
7107 int res1 = 0 ;
7108 PyObject *swig_obj[1] ;
7109
7110 if (!args) SWIG_fail;
7111 swig_obj[0] = args;
7112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7113 if (!SWIG_IsOK(res1)) {
7114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7115 }
7116 arg1 = reinterpret_cast< wxRect * >(argp1);
7117 {
7118 result = (int)((wxRect const *)arg1)->GetRight();
7119 if (PyErr_Occurred()) SWIG_fail;
7120 }
7121 resultobj = SWIG_From_int(static_cast< int >(result));
7122 return resultobj;
7123 fail:
7124 return NULL;
7125 }
7126
7127
7128 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7129 PyObject *resultobj = 0;
7130 wxRect *arg1 = (wxRect *) 0 ;
7131 int arg2 ;
7132 void *argp1 = 0 ;
7133 int res1 = 0 ;
7134 int val2 ;
7135 int ecode2 = 0 ;
7136 PyObject * obj0 = 0 ;
7137 PyObject * obj1 = 0 ;
7138 char * kwnames[] = {
7139 (char *) "self",(char *) "left", NULL
7140 };
7141
7142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7144 if (!SWIG_IsOK(res1)) {
7145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7146 }
7147 arg1 = reinterpret_cast< wxRect * >(argp1);
7148 ecode2 = SWIG_AsVal_int(obj1, &val2);
7149 if (!SWIG_IsOK(ecode2)) {
7150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7151 }
7152 arg2 = static_cast< int >(val2);
7153 {
7154 (arg1)->SetLeft(arg2);
7155 if (PyErr_Occurred()) SWIG_fail;
7156 }
7157 resultobj = SWIG_Py_Void();
7158 return resultobj;
7159 fail:
7160 return NULL;
7161 }
7162
7163
7164 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7165 PyObject *resultobj = 0;
7166 wxRect *arg1 = (wxRect *) 0 ;
7167 int arg2 ;
7168 void *argp1 = 0 ;
7169 int res1 = 0 ;
7170 int val2 ;
7171 int ecode2 = 0 ;
7172 PyObject * obj0 = 0 ;
7173 PyObject * obj1 = 0 ;
7174 char * kwnames[] = {
7175 (char *) "self",(char *) "right", NULL
7176 };
7177
7178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7180 if (!SWIG_IsOK(res1)) {
7181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7182 }
7183 arg1 = reinterpret_cast< wxRect * >(argp1);
7184 ecode2 = SWIG_AsVal_int(obj1, &val2);
7185 if (!SWIG_IsOK(ecode2)) {
7186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7187 }
7188 arg2 = static_cast< int >(val2);
7189 {
7190 (arg1)->SetRight(arg2);
7191 if (PyErr_Occurred()) SWIG_fail;
7192 }
7193 resultobj = SWIG_Py_Void();
7194 return resultobj;
7195 fail:
7196 return NULL;
7197 }
7198
7199
7200 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7201 PyObject *resultobj = 0;
7202 wxRect *arg1 = (wxRect *) 0 ;
7203 int arg2 ;
7204 void *argp1 = 0 ;
7205 int res1 = 0 ;
7206 int val2 ;
7207 int ecode2 = 0 ;
7208 PyObject * obj0 = 0 ;
7209 PyObject * obj1 = 0 ;
7210 char * kwnames[] = {
7211 (char *) "self",(char *) "top", NULL
7212 };
7213
7214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7216 if (!SWIG_IsOK(res1)) {
7217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7218 }
7219 arg1 = reinterpret_cast< wxRect * >(argp1);
7220 ecode2 = SWIG_AsVal_int(obj1, &val2);
7221 if (!SWIG_IsOK(ecode2)) {
7222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7223 }
7224 arg2 = static_cast< int >(val2);
7225 {
7226 (arg1)->SetTop(arg2);
7227 if (PyErr_Occurred()) SWIG_fail;
7228 }
7229 resultobj = SWIG_Py_Void();
7230 return resultobj;
7231 fail:
7232 return NULL;
7233 }
7234
7235
7236 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7237 PyObject *resultobj = 0;
7238 wxRect *arg1 = (wxRect *) 0 ;
7239 int arg2 ;
7240 void *argp1 = 0 ;
7241 int res1 = 0 ;
7242 int val2 ;
7243 int ecode2 = 0 ;
7244 PyObject * obj0 = 0 ;
7245 PyObject * obj1 = 0 ;
7246 char * kwnames[] = {
7247 (char *) "self",(char *) "bottom", NULL
7248 };
7249
7250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7252 if (!SWIG_IsOK(res1)) {
7253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7254 }
7255 arg1 = reinterpret_cast< wxRect * >(argp1);
7256 ecode2 = SWIG_AsVal_int(obj1, &val2);
7257 if (!SWIG_IsOK(ecode2)) {
7258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7259 }
7260 arg2 = static_cast< int >(val2);
7261 {
7262 (arg1)->SetBottom(arg2);
7263 if (PyErr_Occurred()) SWIG_fail;
7264 }
7265 resultobj = SWIG_Py_Void();
7266 return resultobj;
7267 fail:
7268 return NULL;
7269 }
7270
7271
7272 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7273 PyObject *resultobj = 0;
7274 wxRect *arg1 = (wxRect *) 0 ;
7275 int arg2 ;
7276 int arg3 ;
7277 wxRect *result = 0 ;
7278 void *argp1 = 0 ;
7279 int res1 = 0 ;
7280 int val2 ;
7281 int ecode2 = 0 ;
7282 int val3 ;
7283 int ecode3 = 0 ;
7284 PyObject * obj0 = 0 ;
7285 PyObject * obj1 = 0 ;
7286 PyObject * obj2 = 0 ;
7287 char * kwnames[] = {
7288 (char *) "self",(char *) "dx",(char *) "dy", NULL
7289 };
7290
7291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7293 if (!SWIG_IsOK(res1)) {
7294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7295 }
7296 arg1 = reinterpret_cast< wxRect * >(argp1);
7297 ecode2 = SWIG_AsVal_int(obj1, &val2);
7298 if (!SWIG_IsOK(ecode2)) {
7299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7300 }
7301 arg2 = static_cast< int >(val2);
7302 ecode3 = SWIG_AsVal_int(obj2, &val3);
7303 if (!SWIG_IsOK(ecode3)) {
7304 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7305 }
7306 arg3 = static_cast< int >(val3);
7307 {
7308 {
7309 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7310 result = (wxRect *) &_result_ref;
7311 }
7312 if (PyErr_Occurred()) SWIG_fail;
7313 }
7314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7315 return resultobj;
7316 fail:
7317 return NULL;
7318 }
7319
7320
7321 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7322 PyObject *resultobj = 0;
7323 wxRect *arg1 = (wxRect *) 0 ;
7324 int arg2 ;
7325 int arg3 ;
7326 wxRect *result = 0 ;
7327 void *argp1 = 0 ;
7328 int res1 = 0 ;
7329 int val2 ;
7330 int ecode2 = 0 ;
7331 int val3 ;
7332 int ecode3 = 0 ;
7333 PyObject * obj0 = 0 ;
7334 PyObject * obj1 = 0 ;
7335 PyObject * obj2 = 0 ;
7336 char * kwnames[] = {
7337 (char *) "self",(char *) "dx",(char *) "dy", NULL
7338 };
7339
7340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7342 if (!SWIG_IsOK(res1)) {
7343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7344 }
7345 arg1 = reinterpret_cast< wxRect * >(argp1);
7346 ecode2 = SWIG_AsVal_int(obj1, &val2);
7347 if (!SWIG_IsOK(ecode2)) {
7348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7349 }
7350 arg2 = static_cast< int >(val2);
7351 ecode3 = SWIG_AsVal_int(obj2, &val3);
7352 if (!SWIG_IsOK(ecode3)) {
7353 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7354 }
7355 arg3 = static_cast< int >(val3);
7356 {
7357 {
7358 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7359 result = (wxRect *) &_result_ref;
7360 }
7361 if (PyErr_Occurred()) SWIG_fail;
7362 }
7363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7364 return resultobj;
7365 fail:
7366 return NULL;
7367 }
7368
7369
7370 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7371 PyObject *resultobj = 0;
7372 wxRect *arg1 = (wxRect *) 0 ;
7373 int arg2 ;
7374 int arg3 ;
7375 void *argp1 = 0 ;
7376 int res1 = 0 ;
7377 int val2 ;
7378 int ecode2 = 0 ;
7379 int val3 ;
7380 int ecode3 = 0 ;
7381 PyObject * obj0 = 0 ;
7382 PyObject * obj1 = 0 ;
7383 PyObject * obj2 = 0 ;
7384 char * kwnames[] = {
7385 (char *) "self",(char *) "dx",(char *) "dy", NULL
7386 };
7387
7388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7390 if (!SWIG_IsOK(res1)) {
7391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7392 }
7393 arg1 = reinterpret_cast< wxRect * >(argp1);
7394 ecode2 = SWIG_AsVal_int(obj1, &val2);
7395 if (!SWIG_IsOK(ecode2)) {
7396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7397 }
7398 arg2 = static_cast< int >(val2);
7399 ecode3 = SWIG_AsVal_int(obj2, &val3);
7400 if (!SWIG_IsOK(ecode3)) {
7401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7402 }
7403 arg3 = static_cast< int >(val3);
7404 {
7405 (arg1)->Offset(arg2,arg3);
7406 if (PyErr_Occurred()) SWIG_fail;
7407 }
7408 resultobj = SWIG_Py_Void();
7409 return resultobj;
7410 fail:
7411 return NULL;
7412 }
7413
7414
7415 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7416 PyObject *resultobj = 0;
7417 wxRect *arg1 = (wxRect *) 0 ;
7418 wxPoint *arg2 = 0 ;
7419 void *argp1 = 0 ;
7420 int res1 = 0 ;
7421 wxPoint temp2 ;
7422 PyObject * obj0 = 0 ;
7423 PyObject * obj1 = 0 ;
7424 char * kwnames[] = {
7425 (char *) "self",(char *) "pt", NULL
7426 };
7427
7428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7430 if (!SWIG_IsOK(res1)) {
7431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7432 }
7433 arg1 = reinterpret_cast< wxRect * >(argp1);
7434 {
7435 arg2 = &temp2;
7436 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7437 }
7438 {
7439 (arg1)->Offset((wxPoint const &)*arg2);
7440 if (PyErr_Occurred()) SWIG_fail;
7441 }
7442 resultobj = SWIG_Py_Void();
7443 return resultobj;
7444 fail:
7445 return NULL;
7446 }
7447
7448
7449 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7450 PyObject *resultobj = 0;
7451 wxRect *arg1 = (wxRect *) 0 ;
7452 wxRect *arg2 = 0 ;
7453 wxRect result;
7454 void *argp1 = 0 ;
7455 int res1 = 0 ;
7456 wxRect temp2 ;
7457 PyObject * obj0 = 0 ;
7458 PyObject * obj1 = 0 ;
7459 char * kwnames[] = {
7460 (char *) "self",(char *) "rect", NULL
7461 };
7462
7463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7465 if (!SWIG_IsOK(res1)) {
7466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7467 }
7468 arg1 = reinterpret_cast< wxRect * >(argp1);
7469 {
7470 arg2 = &temp2;
7471 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7472 }
7473 {
7474 result = (arg1)->Intersect((wxRect const &)*arg2);
7475 if (PyErr_Occurred()) SWIG_fail;
7476 }
7477 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7478 return resultobj;
7479 fail:
7480 return NULL;
7481 }
7482
7483
7484 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7485 PyObject *resultobj = 0;
7486 wxRect *arg1 = (wxRect *) 0 ;
7487 wxRect *arg2 = 0 ;
7488 wxRect result;
7489 void *argp1 = 0 ;
7490 int res1 = 0 ;
7491 wxRect temp2 ;
7492 PyObject * obj0 = 0 ;
7493 PyObject * obj1 = 0 ;
7494 char * kwnames[] = {
7495 (char *) "self",(char *) "rect", NULL
7496 };
7497
7498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7500 if (!SWIG_IsOK(res1)) {
7501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7502 }
7503 arg1 = reinterpret_cast< wxRect * >(argp1);
7504 {
7505 arg2 = &temp2;
7506 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7507 }
7508 {
7509 result = (arg1)->Union((wxRect const &)*arg2);
7510 if (PyErr_Occurred()) SWIG_fail;
7511 }
7512 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7513 return resultobj;
7514 fail:
7515 return NULL;
7516 }
7517
7518
7519 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7520 PyObject *resultobj = 0;
7521 wxRect *arg1 = (wxRect *) 0 ;
7522 wxRect *arg2 = 0 ;
7523 wxRect result;
7524 void *argp1 = 0 ;
7525 int res1 = 0 ;
7526 wxRect temp2 ;
7527 PyObject * obj0 = 0 ;
7528 PyObject * obj1 = 0 ;
7529 char * kwnames[] = {
7530 (char *) "self",(char *) "rect", NULL
7531 };
7532
7533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7535 if (!SWIG_IsOK(res1)) {
7536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7537 }
7538 arg1 = reinterpret_cast< wxRect * >(argp1);
7539 {
7540 arg2 = &temp2;
7541 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7542 }
7543 {
7544 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7545 if (PyErr_Occurred()) SWIG_fail;
7546 }
7547 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7548 return resultobj;
7549 fail:
7550 return NULL;
7551 }
7552
7553
7554 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7555 PyObject *resultobj = 0;
7556 wxRect *arg1 = (wxRect *) 0 ;
7557 wxRect *arg2 = 0 ;
7558 wxRect *result = 0 ;
7559 void *argp1 = 0 ;
7560 int res1 = 0 ;
7561 wxRect temp2 ;
7562 PyObject * obj0 = 0 ;
7563 PyObject * obj1 = 0 ;
7564 char * kwnames[] = {
7565 (char *) "self",(char *) "rect", NULL
7566 };
7567
7568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7570 if (!SWIG_IsOK(res1)) {
7571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7572 }
7573 arg1 = reinterpret_cast< wxRect * >(argp1);
7574 {
7575 arg2 = &temp2;
7576 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7577 }
7578 {
7579 {
7580 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7581 result = (wxRect *) &_result_ref;
7582 }
7583 if (PyErr_Occurred()) SWIG_fail;
7584 }
7585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7586 return resultobj;
7587 fail:
7588 return NULL;
7589 }
7590
7591
7592 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7593 PyObject *resultobj = 0;
7594 wxRect *arg1 = (wxRect *) 0 ;
7595 PyObject *arg2 = (PyObject *) 0 ;
7596 bool result;
7597 void *argp1 = 0 ;
7598 int res1 = 0 ;
7599 PyObject * obj0 = 0 ;
7600 PyObject * obj1 = 0 ;
7601 char * kwnames[] = {
7602 (char *) "self",(char *) "other", NULL
7603 };
7604
7605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7607 if (!SWIG_IsOK(res1)) {
7608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7609 }
7610 arg1 = reinterpret_cast< wxRect * >(argp1);
7611 arg2 = obj1;
7612 {
7613 result = (bool)wxRect___eq__(arg1,arg2);
7614 if (PyErr_Occurred()) SWIG_fail;
7615 }
7616 {
7617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7618 }
7619 return resultobj;
7620 fail:
7621 return NULL;
7622 }
7623
7624
7625 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7626 PyObject *resultobj = 0;
7627 wxRect *arg1 = (wxRect *) 0 ;
7628 PyObject *arg2 = (PyObject *) 0 ;
7629 bool result;
7630 void *argp1 = 0 ;
7631 int res1 = 0 ;
7632 PyObject * obj0 = 0 ;
7633 PyObject * obj1 = 0 ;
7634 char * kwnames[] = {
7635 (char *) "self",(char *) "other", NULL
7636 };
7637
7638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7640 if (!SWIG_IsOK(res1)) {
7641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7642 }
7643 arg1 = reinterpret_cast< wxRect * >(argp1);
7644 arg2 = obj1;
7645 {
7646 result = (bool)wxRect___ne__(arg1,arg2);
7647 if (PyErr_Occurred()) SWIG_fail;
7648 }
7649 {
7650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7651 }
7652 return resultobj;
7653 fail:
7654 return NULL;
7655 }
7656
7657
7658 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7659 PyObject *resultobj = 0;
7660 wxRect *arg1 = (wxRect *) 0 ;
7661 int arg2 ;
7662 int arg3 ;
7663 bool result;
7664 void *argp1 = 0 ;
7665 int res1 = 0 ;
7666 int val2 ;
7667 int ecode2 = 0 ;
7668 int val3 ;
7669 int ecode3 = 0 ;
7670 PyObject * obj0 = 0 ;
7671 PyObject * obj1 = 0 ;
7672 PyObject * obj2 = 0 ;
7673 char * kwnames[] = {
7674 (char *) "self",(char *) "x",(char *) "y", NULL
7675 };
7676
7677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7679 if (!SWIG_IsOK(res1)) {
7680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7681 }
7682 arg1 = reinterpret_cast< wxRect * >(argp1);
7683 ecode2 = SWIG_AsVal_int(obj1, &val2);
7684 if (!SWIG_IsOK(ecode2)) {
7685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7686 }
7687 arg2 = static_cast< int >(val2);
7688 ecode3 = SWIG_AsVal_int(obj2, &val3);
7689 if (!SWIG_IsOK(ecode3)) {
7690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7691 }
7692 arg3 = static_cast< int >(val3);
7693 {
7694 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7695 if (PyErr_Occurred()) SWIG_fail;
7696 }
7697 {
7698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7699 }
7700 return resultobj;
7701 fail:
7702 return NULL;
7703 }
7704
7705
7706 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7707 PyObject *resultobj = 0;
7708 wxRect *arg1 = (wxRect *) 0 ;
7709 wxPoint *arg2 = 0 ;
7710 bool result;
7711 void *argp1 = 0 ;
7712 int res1 = 0 ;
7713 wxPoint temp2 ;
7714 PyObject * obj0 = 0 ;
7715 PyObject * obj1 = 0 ;
7716 char * kwnames[] = {
7717 (char *) "self",(char *) "pt", NULL
7718 };
7719
7720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7722 if (!SWIG_IsOK(res1)) {
7723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7724 }
7725 arg1 = reinterpret_cast< wxRect * >(argp1);
7726 {
7727 arg2 = &temp2;
7728 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7729 }
7730 {
7731 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7732 if (PyErr_Occurred()) SWIG_fail;
7733 }
7734 {
7735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7736 }
7737 return resultobj;
7738 fail:
7739 return NULL;
7740 }
7741
7742
7743 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7744 PyObject *resultobj = 0;
7745 wxRect *arg1 = (wxRect *) 0 ;
7746 wxRect *arg2 = 0 ;
7747 bool result;
7748 void *argp1 = 0 ;
7749 int res1 = 0 ;
7750 wxRect temp2 ;
7751 PyObject * obj0 = 0 ;
7752 PyObject * obj1 = 0 ;
7753 char * kwnames[] = {
7754 (char *) "self",(char *) "rect", NULL
7755 };
7756
7757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7759 if (!SWIG_IsOK(res1)) {
7760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7761 }
7762 arg1 = reinterpret_cast< wxRect * >(argp1);
7763 {
7764 arg2 = &temp2;
7765 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7766 }
7767 {
7768 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7769 if (PyErr_Occurred()) SWIG_fail;
7770 }
7771 {
7772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7773 }
7774 return resultobj;
7775 fail:
7776 return NULL;
7777 }
7778
7779
7780 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7781 PyObject *resultobj = 0;
7782 wxRect *arg1 = (wxRect *) 0 ;
7783 wxRect *arg2 = 0 ;
7784 bool result;
7785 void *argp1 = 0 ;
7786 int res1 = 0 ;
7787 wxRect temp2 ;
7788 PyObject * obj0 = 0 ;
7789 PyObject * obj1 = 0 ;
7790 char * kwnames[] = {
7791 (char *) "self",(char *) "rect", NULL
7792 };
7793
7794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7796 if (!SWIG_IsOK(res1)) {
7797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7798 }
7799 arg1 = reinterpret_cast< wxRect * >(argp1);
7800 {
7801 arg2 = &temp2;
7802 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7803 }
7804 {
7805 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7806 if (PyErr_Occurred()) SWIG_fail;
7807 }
7808 {
7809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7810 }
7811 return resultobj;
7812 fail:
7813 return NULL;
7814 }
7815
7816
7817 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7818 PyObject *resultobj = 0;
7819 wxRect *arg1 = (wxRect *) 0 ;
7820 wxRect *arg2 = 0 ;
7821 int arg3 = (int) wxBOTH ;
7822 wxRect result;
7823 void *argp1 = 0 ;
7824 int res1 = 0 ;
7825 wxRect temp2 ;
7826 int val3 ;
7827 int ecode3 = 0 ;
7828 PyObject * obj0 = 0 ;
7829 PyObject * obj1 = 0 ;
7830 PyObject * obj2 = 0 ;
7831 char * kwnames[] = {
7832 (char *) "self",(char *) "r",(char *) "dir", NULL
7833 };
7834
7835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7837 if (!SWIG_IsOK(res1)) {
7838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7839 }
7840 arg1 = reinterpret_cast< wxRect * >(argp1);
7841 {
7842 arg2 = &temp2;
7843 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7844 }
7845 if (obj2) {
7846 ecode3 = SWIG_AsVal_int(obj2, &val3);
7847 if (!SWIG_IsOK(ecode3)) {
7848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7849 }
7850 arg3 = static_cast< int >(val3);
7851 }
7852 {
7853 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7854 if (PyErr_Occurred()) SWIG_fail;
7855 }
7856 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7857 return resultobj;
7858 fail:
7859 return NULL;
7860 }
7861
7862
7863 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7864 PyObject *resultobj = 0;
7865 wxRect *arg1 = (wxRect *) 0 ;
7866 int arg2 ;
7867 void *argp1 = 0 ;
7868 int res1 = 0 ;
7869 int val2 ;
7870 int ecode2 = 0 ;
7871 PyObject *swig_obj[2] ;
7872
7873 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7875 if (!SWIG_IsOK(res1)) {
7876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7877 }
7878 arg1 = reinterpret_cast< wxRect * >(argp1);
7879 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7880 if (!SWIG_IsOK(ecode2)) {
7881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7882 }
7883 arg2 = static_cast< int >(val2);
7884 if (arg1) (arg1)->x = arg2;
7885
7886 resultobj = SWIG_Py_Void();
7887 return resultobj;
7888 fail:
7889 return NULL;
7890 }
7891
7892
7893 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7894 PyObject *resultobj = 0;
7895 wxRect *arg1 = (wxRect *) 0 ;
7896 int result;
7897 void *argp1 = 0 ;
7898 int res1 = 0 ;
7899 PyObject *swig_obj[1] ;
7900
7901 if (!args) SWIG_fail;
7902 swig_obj[0] = args;
7903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7904 if (!SWIG_IsOK(res1)) {
7905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7906 }
7907 arg1 = reinterpret_cast< wxRect * >(argp1);
7908 result = (int) ((arg1)->x);
7909 resultobj = SWIG_From_int(static_cast< int >(result));
7910 return resultobj;
7911 fail:
7912 return NULL;
7913 }
7914
7915
7916 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7917 PyObject *resultobj = 0;
7918 wxRect *arg1 = (wxRect *) 0 ;
7919 int arg2 ;
7920 void *argp1 = 0 ;
7921 int res1 = 0 ;
7922 int val2 ;
7923 int ecode2 = 0 ;
7924 PyObject *swig_obj[2] ;
7925
7926 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7928 if (!SWIG_IsOK(res1)) {
7929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7930 }
7931 arg1 = reinterpret_cast< wxRect * >(argp1);
7932 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7933 if (!SWIG_IsOK(ecode2)) {
7934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7935 }
7936 arg2 = static_cast< int >(val2);
7937 if (arg1) (arg1)->y = arg2;
7938
7939 resultobj = SWIG_Py_Void();
7940 return resultobj;
7941 fail:
7942 return NULL;
7943 }
7944
7945
7946 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7947 PyObject *resultobj = 0;
7948 wxRect *arg1 = (wxRect *) 0 ;
7949 int result;
7950 void *argp1 = 0 ;
7951 int res1 = 0 ;
7952 PyObject *swig_obj[1] ;
7953
7954 if (!args) SWIG_fail;
7955 swig_obj[0] = args;
7956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7957 if (!SWIG_IsOK(res1)) {
7958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7959 }
7960 arg1 = reinterpret_cast< wxRect * >(argp1);
7961 result = (int) ((arg1)->y);
7962 resultobj = SWIG_From_int(static_cast< int >(result));
7963 return resultobj;
7964 fail:
7965 return NULL;
7966 }
7967
7968
7969 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7970 PyObject *resultobj = 0;
7971 wxRect *arg1 = (wxRect *) 0 ;
7972 int arg2 ;
7973 void *argp1 = 0 ;
7974 int res1 = 0 ;
7975 int val2 ;
7976 int ecode2 = 0 ;
7977 PyObject *swig_obj[2] ;
7978
7979 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7981 if (!SWIG_IsOK(res1)) {
7982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7983 }
7984 arg1 = reinterpret_cast< wxRect * >(argp1);
7985 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7986 if (!SWIG_IsOK(ecode2)) {
7987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7988 }
7989 arg2 = static_cast< int >(val2);
7990 if (arg1) (arg1)->width = arg2;
7991
7992 resultobj = SWIG_Py_Void();
7993 return resultobj;
7994 fail:
7995 return NULL;
7996 }
7997
7998
7999 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8000 PyObject *resultobj = 0;
8001 wxRect *arg1 = (wxRect *) 0 ;
8002 int result;
8003 void *argp1 = 0 ;
8004 int res1 = 0 ;
8005 PyObject *swig_obj[1] ;
8006
8007 if (!args) SWIG_fail;
8008 swig_obj[0] = args;
8009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8010 if (!SWIG_IsOK(res1)) {
8011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8012 }
8013 arg1 = reinterpret_cast< wxRect * >(argp1);
8014 result = (int) ((arg1)->width);
8015 resultobj = SWIG_From_int(static_cast< int >(result));
8016 return resultobj;
8017 fail:
8018 return NULL;
8019 }
8020
8021
8022 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8023 PyObject *resultobj = 0;
8024 wxRect *arg1 = (wxRect *) 0 ;
8025 int arg2 ;
8026 void *argp1 = 0 ;
8027 int res1 = 0 ;
8028 int val2 ;
8029 int ecode2 = 0 ;
8030 PyObject *swig_obj[2] ;
8031
8032 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8034 if (!SWIG_IsOK(res1)) {
8035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8036 }
8037 arg1 = reinterpret_cast< wxRect * >(argp1);
8038 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8039 if (!SWIG_IsOK(ecode2)) {
8040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8041 }
8042 arg2 = static_cast< int >(val2);
8043 if (arg1) (arg1)->height = arg2;
8044
8045 resultobj = SWIG_Py_Void();
8046 return resultobj;
8047 fail:
8048 return NULL;
8049 }
8050
8051
8052 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8053 PyObject *resultobj = 0;
8054 wxRect *arg1 = (wxRect *) 0 ;
8055 int result;
8056 void *argp1 = 0 ;
8057 int res1 = 0 ;
8058 PyObject *swig_obj[1] ;
8059
8060 if (!args) SWIG_fail;
8061 swig_obj[0] = args;
8062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8063 if (!SWIG_IsOK(res1)) {
8064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8065 }
8066 arg1 = reinterpret_cast< wxRect * >(argp1);
8067 result = (int) ((arg1)->height);
8068 resultobj = SWIG_From_int(static_cast< int >(result));
8069 return resultobj;
8070 fail:
8071 return NULL;
8072 }
8073
8074
8075 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8076 PyObject *resultobj = 0;
8077 wxRect *arg1 = (wxRect *) 0 ;
8078 int arg2 = (int) 0 ;
8079 int arg3 = (int) 0 ;
8080 int arg4 = (int) 0 ;
8081 int arg5 = (int) 0 ;
8082 void *argp1 = 0 ;
8083 int res1 = 0 ;
8084 int val2 ;
8085 int ecode2 = 0 ;
8086 int val3 ;
8087 int ecode3 = 0 ;
8088 int val4 ;
8089 int ecode4 = 0 ;
8090 int val5 ;
8091 int ecode5 = 0 ;
8092 PyObject * obj0 = 0 ;
8093 PyObject * obj1 = 0 ;
8094 PyObject * obj2 = 0 ;
8095 PyObject * obj3 = 0 ;
8096 PyObject * obj4 = 0 ;
8097 char * kwnames[] = {
8098 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8099 };
8100
8101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8103 if (!SWIG_IsOK(res1)) {
8104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8105 }
8106 arg1 = reinterpret_cast< wxRect * >(argp1);
8107 if (obj1) {
8108 ecode2 = SWIG_AsVal_int(obj1, &val2);
8109 if (!SWIG_IsOK(ecode2)) {
8110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8111 }
8112 arg2 = static_cast< int >(val2);
8113 }
8114 if (obj2) {
8115 ecode3 = SWIG_AsVal_int(obj2, &val3);
8116 if (!SWIG_IsOK(ecode3)) {
8117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8118 }
8119 arg3 = static_cast< int >(val3);
8120 }
8121 if (obj3) {
8122 ecode4 = SWIG_AsVal_int(obj3, &val4);
8123 if (!SWIG_IsOK(ecode4)) {
8124 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8125 }
8126 arg4 = static_cast< int >(val4);
8127 }
8128 if (obj4) {
8129 ecode5 = SWIG_AsVal_int(obj4, &val5);
8130 if (!SWIG_IsOK(ecode5)) {
8131 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8132 }
8133 arg5 = static_cast< int >(val5);
8134 }
8135 {
8136 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8137 if (PyErr_Occurred()) SWIG_fail;
8138 }
8139 resultobj = SWIG_Py_Void();
8140 return resultobj;
8141 fail:
8142 return NULL;
8143 }
8144
8145
8146 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8147 PyObject *resultobj = 0;
8148 wxRect *arg1 = (wxRect *) 0 ;
8149 PyObject *result = 0 ;
8150 void *argp1 = 0 ;
8151 int res1 = 0 ;
8152 PyObject *swig_obj[1] ;
8153
8154 if (!args) SWIG_fail;
8155 swig_obj[0] = args;
8156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8157 if (!SWIG_IsOK(res1)) {
8158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8159 }
8160 arg1 = reinterpret_cast< wxRect * >(argp1);
8161 {
8162 result = (PyObject *)wxRect_Get(arg1);
8163 if (PyErr_Occurred()) SWIG_fail;
8164 }
8165 resultobj = result;
8166 return resultobj;
8167 fail:
8168 return NULL;
8169 }
8170
8171
8172 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8173 PyObject *obj;
8174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8175 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8176 return SWIG_Py_Void();
8177 }
8178
8179 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8180 return SWIG_Python_InitShadowInstance(args);
8181 }
8182
8183 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8184 PyObject *resultobj = 0;
8185 wxRect *arg1 = (wxRect *) 0 ;
8186 wxRect *arg2 = (wxRect *) 0 ;
8187 PyObject *result = 0 ;
8188 void *argp1 = 0 ;
8189 int res1 = 0 ;
8190 void *argp2 = 0 ;
8191 int res2 = 0 ;
8192 PyObject * obj0 = 0 ;
8193 PyObject * obj1 = 0 ;
8194 char * kwnames[] = {
8195 (char *) "r1",(char *) "r2", NULL
8196 };
8197
8198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8200 if (!SWIG_IsOK(res1)) {
8201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8202 }
8203 arg1 = reinterpret_cast< wxRect * >(argp1);
8204 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8205 if (!SWIG_IsOK(res2)) {
8206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8207 }
8208 arg2 = reinterpret_cast< wxRect * >(argp2);
8209 {
8210 if (!wxPyCheckForApp()) SWIG_fail;
8211 PyThreadState* __tstate = wxPyBeginAllowThreads();
8212 result = (PyObject *)wxIntersectRect(arg1,arg2);
8213 wxPyEndAllowThreads(__tstate);
8214 if (PyErr_Occurred()) SWIG_fail;
8215 }
8216 resultobj = result;
8217 return resultobj;
8218 fail:
8219 return NULL;
8220 }
8221
8222
8223 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8224 PyObject *resultobj = 0;
8225 double arg1 = (double) 0.0 ;
8226 double arg2 = (double) 0.0 ;
8227 wxPoint2D *result = 0 ;
8228 double val1 ;
8229 int ecode1 = 0 ;
8230 double val2 ;
8231 int ecode2 = 0 ;
8232 PyObject * obj0 = 0 ;
8233 PyObject * obj1 = 0 ;
8234 char * kwnames[] = {
8235 (char *) "x",(char *) "y", NULL
8236 };
8237
8238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8239 if (obj0) {
8240 ecode1 = SWIG_AsVal_double(obj0, &val1);
8241 if (!SWIG_IsOK(ecode1)) {
8242 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8243 }
8244 arg1 = static_cast< double >(val1);
8245 }
8246 if (obj1) {
8247 ecode2 = SWIG_AsVal_double(obj1, &val2);
8248 if (!SWIG_IsOK(ecode2)) {
8249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8250 }
8251 arg2 = static_cast< double >(val2);
8252 }
8253 {
8254 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8255 if (PyErr_Occurred()) SWIG_fail;
8256 }
8257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8258 return resultobj;
8259 fail:
8260 return NULL;
8261 }
8262
8263
8264 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8265 PyObject *resultobj = 0;
8266 wxPoint2D *arg1 = 0 ;
8267 wxPoint2D *result = 0 ;
8268 wxPoint2D temp1 ;
8269 PyObject * obj0 = 0 ;
8270 char * kwnames[] = {
8271 (char *) "pt", NULL
8272 };
8273
8274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8275 {
8276 arg1 = &temp1;
8277 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8278 }
8279 {
8280 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8281 if (PyErr_Occurred()) SWIG_fail;
8282 }
8283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8284 return resultobj;
8285 fail:
8286 return NULL;
8287 }
8288
8289
8290 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8291 PyObject *resultobj = 0;
8292 wxPoint *arg1 = 0 ;
8293 wxPoint2D *result = 0 ;
8294 wxPoint temp1 ;
8295 PyObject * obj0 = 0 ;
8296 char * kwnames[] = {
8297 (char *) "pt", NULL
8298 };
8299
8300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8301 {
8302 arg1 = &temp1;
8303 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8304 }
8305 {
8306 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8307 if (PyErr_Occurred()) SWIG_fail;
8308 }
8309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8310 return resultobj;
8311 fail:
8312 return NULL;
8313 }
8314
8315
8316 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8317 PyObject *resultobj = 0;
8318 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8319 void *argp1 = 0 ;
8320 int res1 = 0 ;
8321 PyObject *swig_obj[1] ;
8322
8323 if (!args) SWIG_fail;
8324 swig_obj[0] = args;
8325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8326 if (!SWIG_IsOK(res1)) {
8327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8328 }
8329 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8330 {
8331 delete arg1;
8332
8333 if (PyErr_Occurred()) SWIG_fail;
8334 }
8335 resultobj = SWIG_Py_Void();
8336 return resultobj;
8337 fail:
8338 return NULL;
8339 }
8340
8341
8342 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8343 PyObject *resultobj = 0;
8344 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8345 int *arg2 = (int *) 0 ;
8346 int *arg3 = (int *) 0 ;
8347 void *argp1 = 0 ;
8348 int res1 = 0 ;
8349 int temp2 ;
8350 int res2 = SWIG_TMPOBJ ;
8351 int temp3 ;
8352 int res3 = SWIG_TMPOBJ ;
8353 PyObject *swig_obj[1] ;
8354
8355 arg2 = &temp2;
8356 arg3 = &temp3;
8357 if (!args) SWIG_fail;
8358 swig_obj[0] = args;
8359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8360 if (!SWIG_IsOK(res1)) {
8361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8362 }
8363 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8364 {
8365 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8366 if (PyErr_Occurred()) SWIG_fail;
8367 }
8368 resultobj = SWIG_Py_Void();
8369 if (SWIG_IsTmpObj(res2)) {
8370 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8371 } else {
8372 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8373 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8374 }
8375 if (SWIG_IsTmpObj(res3)) {
8376 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8377 } else {
8378 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8379 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8380 }
8381 return resultobj;
8382 fail:
8383 return NULL;
8384 }
8385
8386
8387 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8388 PyObject *resultobj = 0;
8389 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8390 int *arg2 = (int *) 0 ;
8391 int *arg3 = (int *) 0 ;
8392 void *argp1 = 0 ;
8393 int res1 = 0 ;
8394 int temp2 ;
8395 int res2 = SWIG_TMPOBJ ;
8396 int temp3 ;
8397 int res3 = SWIG_TMPOBJ ;
8398 PyObject *swig_obj[1] ;
8399
8400 arg2 = &temp2;
8401 arg3 = &temp3;
8402 if (!args) SWIG_fail;
8403 swig_obj[0] = args;
8404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8405 if (!SWIG_IsOK(res1)) {
8406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8407 }
8408 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8409 {
8410 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8411 if (PyErr_Occurred()) SWIG_fail;
8412 }
8413 resultobj = SWIG_Py_Void();
8414 if (SWIG_IsTmpObj(res2)) {
8415 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8416 } else {
8417 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8418 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8419 }
8420 if (SWIG_IsTmpObj(res3)) {
8421 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8422 } else {
8423 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8424 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8425 }
8426 return resultobj;
8427 fail:
8428 return NULL;
8429 }
8430
8431
8432 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8433 PyObject *resultobj = 0;
8434 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8435 double result;
8436 void *argp1 = 0 ;
8437 int res1 = 0 ;
8438 PyObject *swig_obj[1] ;
8439
8440 if (!args) SWIG_fail;
8441 swig_obj[0] = args;
8442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8443 if (!SWIG_IsOK(res1)) {
8444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8445 }
8446 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8447 {
8448 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8449 if (PyErr_Occurred()) SWIG_fail;
8450 }
8451 resultobj = SWIG_From_double(static_cast< double >(result));
8452 return resultobj;
8453 fail:
8454 return NULL;
8455 }
8456
8457
8458 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8459 PyObject *resultobj = 0;
8460 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8461 double result;
8462 void *argp1 = 0 ;
8463 int res1 = 0 ;
8464 PyObject *swig_obj[1] ;
8465
8466 if (!args) SWIG_fail;
8467 swig_obj[0] = args;
8468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8469 if (!SWIG_IsOK(res1)) {
8470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8471 }
8472 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8473 {
8474 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8475 if (PyErr_Occurred()) SWIG_fail;
8476 }
8477 resultobj = SWIG_From_double(static_cast< double >(result));
8478 return resultobj;
8479 fail:
8480 return NULL;
8481 }
8482
8483
8484 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8485 PyObject *resultobj = 0;
8486 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8487 double arg2 ;
8488 void *argp1 = 0 ;
8489 int res1 = 0 ;
8490 double val2 ;
8491 int ecode2 = 0 ;
8492 PyObject * obj0 = 0 ;
8493 PyObject * obj1 = 0 ;
8494 char * kwnames[] = {
8495 (char *) "self",(char *) "length", NULL
8496 };
8497
8498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8500 if (!SWIG_IsOK(res1)) {
8501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8502 }
8503 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8504 ecode2 = SWIG_AsVal_double(obj1, &val2);
8505 if (!SWIG_IsOK(ecode2)) {
8506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8507 }
8508 arg2 = static_cast< double >(val2);
8509 {
8510 (arg1)->SetVectorLength(arg2);
8511 if (PyErr_Occurred()) SWIG_fail;
8512 }
8513 resultobj = SWIG_Py_Void();
8514 return resultobj;
8515 fail:
8516 return NULL;
8517 }
8518
8519
8520 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8521 PyObject *resultobj = 0;
8522 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8523 double arg2 ;
8524 void *argp1 = 0 ;
8525 int res1 = 0 ;
8526 double val2 ;
8527 int ecode2 = 0 ;
8528 PyObject * obj0 = 0 ;
8529 PyObject * obj1 = 0 ;
8530 char * kwnames[] = {
8531 (char *) "self",(char *) "degrees", NULL
8532 };
8533
8534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8536 if (!SWIG_IsOK(res1)) {
8537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8538 }
8539 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8540 ecode2 = SWIG_AsVal_double(obj1, &val2);
8541 if (!SWIG_IsOK(ecode2)) {
8542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8543 }
8544 arg2 = static_cast< double >(val2);
8545 {
8546 (arg1)->SetVectorAngle(arg2);
8547 if (PyErr_Occurred()) SWIG_fail;
8548 }
8549 resultobj = SWIG_Py_Void();
8550 return resultobj;
8551 fail:
8552 return NULL;
8553 }
8554
8555
8556 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8557 PyObject *resultobj = 0;
8558 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8559 wxPoint2D *arg2 = 0 ;
8560 double result;
8561 void *argp1 = 0 ;
8562 int res1 = 0 ;
8563 wxPoint2D temp2 ;
8564 PyObject * obj0 = 0 ;
8565 PyObject * obj1 = 0 ;
8566 char * kwnames[] = {
8567 (char *) "self",(char *) "pt", NULL
8568 };
8569
8570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8572 if (!SWIG_IsOK(res1)) {
8573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8574 }
8575 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8576 {
8577 arg2 = &temp2;
8578 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8579 }
8580 {
8581 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8582 if (PyErr_Occurred()) SWIG_fail;
8583 }
8584 resultobj = SWIG_From_double(static_cast< double >(result));
8585 return resultobj;
8586 fail:
8587 return NULL;
8588 }
8589
8590
8591 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8592 PyObject *resultobj = 0;
8593 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8594 wxPoint2D *arg2 = 0 ;
8595 double result;
8596 void *argp1 = 0 ;
8597 int res1 = 0 ;
8598 wxPoint2D temp2 ;
8599 PyObject * obj0 = 0 ;
8600 PyObject * obj1 = 0 ;
8601 char * kwnames[] = {
8602 (char *) "self",(char *) "pt", NULL
8603 };
8604
8605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8607 if (!SWIG_IsOK(res1)) {
8608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8609 }
8610 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8611 {
8612 arg2 = &temp2;
8613 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8614 }
8615 {
8616 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8617 if (PyErr_Occurred()) SWIG_fail;
8618 }
8619 resultobj = SWIG_From_double(static_cast< double >(result));
8620 return resultobj;
8621 fail:
8622 return NULL;
8623 }
8624
8625
8626 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8627 PyObject *resultobj = 0;
8628 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8629 wxPoint2D *arg2 = 0 ;
8630 double result;
8631 void *argp1 = 0 ;
8632 int res1 = 0 ;
8633 wxPoint2D temp2 ;
8634 PyObject * obj0 = 0 ;
8635 PyObject * obj1 = 0 ;
8636 char * kwnames[] = {
8637 (char *) "self",(char *) "vec", NULL
8638 };
8639
8640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8642 if (!SWIG_IsOK(res1)) {
8643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8644 }
8645 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8646 {
8647 arg2 = &temp2;
8648 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8649 }
8650 {
8651 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8652 if (PyErr_Occurred()) SWIG_fail;
8653 }
8654 resultobj = SWIG_From_double(static_cast< double >(result));
8655 return resultobj;
8656 fail:
8657 return NULL;
8658 }
8659
8660
8661 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8662 PyObject *resultobj = 0;
8663 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8664 wxPoint2D *arg2 = 0 ;
8665 double result;
8666 void *argp1 = 0 ;
8667 int res1 = 0 ;
8668 wxPoint2D temp2 ;
8669 PyObject * obj0 = 0 ;
8670 PyObject * obj1 = 0 ;
8671 char * kwnames[] = {
8672 (char *) "self",(char *) "vec", NULL
8673 };
8674
8675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8677 if (!SWIG_IsOK(res1)) {
8678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8679 }
8680 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8681 {
8682 arg2 = &temp2;
8683 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8684 }
8685 {
8686 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8687 if (PyErr_Occurred()) SWIG_fail;
8688 }
8689 resultobj = SWIG_From_double(static_cast< double >(result));
8690 return resultobj;
8691 fail:
8692 return NULL;
8693 }
8694
8695
8696 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8697 PyObject *resultobj = 0;
8698 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8699 wxPoint2D result;
8700 void *argp1 = 0 ;
8701 int res1 = 0 ;
8702 PyObject *swig_obj[1] ;
8703
8704 if (!args) SWIG_fail;
8705 swig_obj[0] = args;
8706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8707 if (!SWIG_IsOK(res1)) {
8708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8709 }
8710 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8711 {
8712 result = (arg1)->operator -();
8713 if (PyErr_Occurred()) SWIG_fail;
8714 }
8715 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8716 return resultobj;
8717 fail:
8718 return NULL;
8719 }
8720
8721
8722 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8723 PyObject *resultobj = 0;
8724 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8725 wxPoint2D *arg2 = 0 ;
8726 wxPoint2D *result = 0 ;
8727 void *argp1 = 0 ;
8728 int res1 = 0 ;
8729 wxPoint2D temp2 ;
8730 PyObject * obj0 = 0 ;
8731 PyObject * obj1 = 0 ;
8732 char * kwnames[] = {
8733 (char *) "self",(char *) "pt", NULL
8734 };
8735
8736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8738 if (!SWIG_IsOK(res1)) {
8739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8740 }
8741 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8742 {
8743 arg2 = &temp2;
8744 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8745 }
8746 {
8747 {
8748 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8749 result = (wxPoint2D *) &_result_ref;
8750 }
8751 if (PyErr_Occurred()) SWIG_fail;
8752 }
8753 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8754 return resultobj;
8755 fail:
8756 return NULL;
8757 }
8758
8759
8760 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8761 PyObject *resultobj = 0;
8762 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8763 wxPoint2D *arg2 = 0 ;
8764 wxPoint2D *result = 0 ;
8765 void *argp1 = 0 ;
8766 int res1 = 0 ;
8767 wxPoint2D temp2 ;
8768 PyObject * obj0 = 0 ;
8769 PyObject * obj1 = 0 ;
8770 char * kwnames[] = {
8771 (char *) "self",(char *) "pt", NULL
8772 };
8773
8774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8776 if (!SWIG_IsOK(res1)) {
8777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8778 }
8779 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8780 {
8781 arg2 = &temp2;
8782 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8783 }
8784 {
8785 {
8786 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8787 result = (wxPoint2D *) &_result_ref;
8788 }
8789 if (PyErr_Occurred()) SWIG_fail;
8790 }
8791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8792 return resultobj;
8793 fail:
8794 return NULL;
8795 }
8796
8797
8798 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8799 PyObject *resultobj = 0;
8800 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8801 wxPoint2D *arg2 = 0 ;
8802 wxPoint2D *result = 0 ;
8803 void *argp1 = 0 ;
8804 int res1 = 0 ;
8805 wxPoint2D temp2 ;
8806 PyObject * obj0 = 0 ;
8807 PyObject * obj1 = 0 ;
8808 char * kwnames[] = {
8809 (char *) "self",(char *) "pt", NULL
8810 };
8811
8812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8814 if (!SWIG_IsOK(res1)) {
8815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8816 }
8817 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8818 {
8819 arg2 = &temp2;
8820 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8821 }
8822 {
8823 {
8824 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8825 result = (wxPoint2D *) &_result_ref;
8826 }
8827 if (PyErr_Occurred()) SWIG_fail;
8828 }
8829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8830 return resultobj;
8831 fail:
8832 return NULL;
8833 }
8834
8835
8836 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8837 PyObject *resultobj = 0;
8838 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8839 wxPoint2D *arg2 = 0 ;
8840 wxPoint2D *result = 0 ;
8841 void *argp1 = 0 ;
8842 int res1 = 0 ;
8843 wxPoint2D temp2 ;
8844 PyObject * obj0 = 0 ;
8845 PyObject * obj1 = 0 ;
8846 char * kwnames[] = {
8847 (char *) "self",(char *) "pt", NULL
8848 };
8849
8850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8852 if (!SWIG_IsOK(res1)) {
8853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8854 }
8855 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8856 {
8857 arg2 = &temp2;
8858 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8859 }
8860 {
8861 {
8862 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8863 result = (wxPoint2D *) &_result_ref;
8864 }
8865 if (PyErr_Occurred()) SWIG_fail;
8866 }
8867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8868 return resultobj;
8869 fail:
8870 return NULL;
8871 }
8872
8873
8874 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8875 PyObject *resultobj = 0;
8876 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8877 PyObject *arg2 = (PyObject *) 0 ;
8878 bool result;
8879 void *argp1 = 0 ;
8880 int res1 = 0 ;
8881 PyObject * obj0 = 0 ;
8882 PyObject * obj1 = 0 ;
8883 char * kwnames[] = {
8884 (char *) "self",(char *) "other", NULL
8885 };
8886
8887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8889 if (!SWIG_IsOK(res1)) {
8890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8891 }
8892 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8893 arg2 = obj1;
8894 {
8895 result = (bool)wxPoint2D___eq__(arg1,arg2);
8896 if (PyErr_Occurred()) SWIG_fail;
8897 }
8898 {
8899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8900 }
8901 return resultobj;
8902 fail:
8903 return NULL;
8904 }
8905
8906
8907 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8908 PyObject *resultobj = 0;
8909 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8910 PyObject *arg2 = (PyObject *) 0 ;
8911 bool result;
8912 void *argp1 = 0 ;
8913 int res1 = 0 ;
8914 PyObject * obj0 = 0 ;
8915 PyObject * obj1 = 0 ;
8916 char * kwnames[] = {
8917 (char *) "self",(char *) "other", NULL
8918 };
8919
8920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8922 if (!SWIG_IsOK(res1)) {
8923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8924 }
8925 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8926 arg2 = obj1;
8927 {
8928 result = (bool)wxPoint2D___ne__(arg1,arg2);
8929 if (PyErr_Occurred()) SWIG_fail;
8930 }
8931 {
8932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8933 }
8934 return resultobj;
8935 fail:
8936 return NULL;
8937 }
8938
8939
8940 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8941 PyObject *resultobj = 0;
8942 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8943 double arg2 ;
8944 void *argp1 = 0 ;
8945 int res1 = 0 ;
8946 double val2 ;
8947 int ecode2 = 0 ;
8948 PyObject *swig_obj[2] ;
8949
8950 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8952 if (!SWIG_IsOK(res1)) {
8953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8954 }
8955 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8956 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8957 if (!SWIG_IsOK(ecode2)) {
8958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8959 }
8960 arg2 = static_cast< double >(val2);
8961 if (arg1) (arg1)->m_x = arg2;
8962
8963 resultobj = SWIG_Py_Void();
8964 return resultobj;
8965 fail:
8966 return NULL;
8967 }
8968
8969
8970 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8971 PyObject *resultobj = 0;
8972 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8973 double result;
8974 void *argp1 = 0 ;
8975 int res1 = 0 ;
8976 PyObject *swig_obj[1] ;
8977
8978 if (!args) SWIG_fail;
8979 swig_obj[0] = args;
8980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8981 if (!SWIG_IsOK(res1)) {
8982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8983 }
8984 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8985 result = (double) ((arg1)->m_x);
8986 resultobj = SWIG_From_double(static_cast< double >(result));
8987 return resultobj;
8988 fail:
8989 return NULL;
8990 }
8991
8992
8993 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8994 PyObject *resultobj = 0;
8995 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8996 double arg2 ;
8997 void *argp1 = 0 ;
8998 int res1 = 0 ;
8999 double val2 ;
9000 int ecode2 = 0 ;
9001 PyObject *swig_obj[2] ;
9002
9003 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9005 if (!SWIG_IsOK(res1)) {
9006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9007 }
9008 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9009 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9010 if (!SWIG_IsOK(ecode2)) {
9011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9012 }
9013 arg2 = static_cast< double >(val2);
9014 if (arg1) (arg1)->m_y = arg2;
9015
9016 resultobj = SWIG_Py_Void();
9017 return resultobj;
9018 fail:
9019 return NULL;
9020 }
9021
9022
9023 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9024 PyObject *resultobj = 0;
9025 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9026 double result;
9027 void *argp1 = 0 ;
9028 int res1 = 0 ;
9029 PyObject *swig_obj[1] ;
9030
9031 if (!args) SWIG_fail;
9032 swig_obj[0] = args;
9033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9034 if (!SWIG_IsOK(res1)) {
9035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9036 }
9037 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9038 result = (double) ((arg1)->m_y);
9039 resultobj = SWIG_From_double(static_cast< double >(result));
9040 return resultobj;
9041 fail:
9042 return NULL;
9043 }
9044
9045
9046 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9047 PyObject *resultobj = 0;
9048 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9049 double arg2 = (double) 0 ;
9050 double arg3 = (double) 0 ;
9051 void *argp1 = 0 ;
9052 int res1 = 0 ;
9053 double val2 ;
9054 int ecode2 = 0 ;
9055 double val3 ;
9056 int ecode3 = 0 ;
9057 PyObject * obj0 = 0 ;
9058 PyObject * obj1 = 0 ;
9059 PyObject * obj2 = 0 ;
9060 char * kwnames[] = {
9061 (char *) "self",(char *) "x",(char *) "y", NULL
9062 };
9063
9064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9066 if (!SWIG_IsOK(res1)) {
9067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9068 }
9069 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9070 if (obj1) {
9071 ecode2 = SWIG_AsVal_double(obj1, &val2);
9072 if (!SWIG_IsOK(ecode2)) {
9073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9074 }
9075 arg2 = static_cast< double >(val2);
9076 }
9077 if (obj2) {
9078 ecode3 = SWIG_AsVal_double(obj2, &val3);
9079 if (!SWIG_IsOK(ecode3)) {
9080 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9081 }
9082 arg3 = static_cast< double >(val3);
9083 }
9084 {
9085 wxPoint2D_Set(arg1,arg2,arg3);
9086 if (PyErr_Occurred()) SWIG_fail;
9087 }
9088 resultobj = SWIG_Py_Void();
9089 return resultobj;
9090 fail:
9091 return NULL;
9092 }
9093
9094
9095 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9096 PyObject *resultobj = 0;
9097 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9098 PyObject *result = 0 ;
9099 void *argp1 = 0 ;
9100 int res1 = 0 ;
9101 PyObject *swig_obj[1] ;
9102
9103 if (!args) SWIG_fail;
9104 swig_obj[0] = args;
9105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9106 if (!SWIG_IsOK(res1)) {
9107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9108 }
9109 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9110 {
9111 result = (PyObject *)wxPoint2D_Get(arg1);
9112 if (PyErr_Occurred()) SWIG_fail;
9113 }
9114 resultobj = result;
9115 return resultobj;
9116 fail:
9117 return NULL;
9118 }
9119
9120
9121 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9122 PyObject *obj;
9123 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9124 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9125 return SWIG_Py_Void();
9126 }
9127
9128 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9129 return SWIG_Python_InitShadowInstance(args);
9130 }
9131
9132 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9133 PyObject *resultobj = 0;
9134 wxDouble arg1 = (wxDouble) 0.0 ;
9135 wxDouble arg2 = (wxDouble) 0.0 ;
9136 wxDouble arg3 = (wxDouble) 0.0 ;
9137 wxDouble arg4 = (wxDouble) 0.0 ;
9138 wxRect2D *result = 0 ;
9139 void *argp1 ;
9140 int res1 = 0 ;
9141 void *argp2 ;
9142 int res2 = 0 ;
9143 void *argp3 ;
9144 int res3 = 0 ;
9145 void *argp4 ;
9146 int res4 = 0 ;
9147 PyObject * obj0 = 0 ;
9148 PyObject * obj1 = 0 ;
9149 PyObject * obj2 = 0 ;
9150 PyObject * obj3 = 0 ;
9151 char * kwnames[] = {
9152 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9153 };
9154
9155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9156 if (obj0) {
9157 {
9158 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9159 if (!SWIG_IsOK(res1)) {
9160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9161 }
9162 if (!argp1) {
9163 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9164 } else {
9165 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9166 arg1 = *temp;
9167 if (SWIG_IsNewObj(res1)) delete temp;
9168 }
9169 }
9170 }
9171 if (obj1) {
9172 {
9173 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9174 if (!SWIG_IsOK(res2)) {
9175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9176 }
9177 if (!argp2) {
9178 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9179 } else {
9180 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9181 arg2 = *temp;
9182 if (SWIG_IsNewObj(res2)) delete temp;
9183 }
9184 }
9185 }
9186 if (obj2) {
9187 {
9188 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9189 if (!SWIG_IsOK(res3)) {
9190 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9191 }
9192 if (!argp3) {
9193 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9194 } else {
9195 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9196 arg3 = *temp;
9197 if (SWIG_IsNewObj(res3)) delete temp;
9198 }
9199 }
9200 }
9201 if (obj3) {
9202 {
9203 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9204 if (!SWIG_IsOK(res4)) {
9205 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9206 }
9207 if (!argp4) {
9208 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9209 } else {
9210 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9211 arg4 = *temp;
9212 if (SWIG_IsNewObj(res4)) delete temp;
9213 }
9214 }
9215 }
9216 {
9217 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9218 if (PyErr_Occurred()) SWIG_fail;
9219 }
9220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9221 return resultobj;
9222 fail:
9223 return NULL;
9224 }
9225
9226
9227 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9228 PyObject *resultobj = 0;
9229 wxRect2D *arg1 = (wxRect2D *) 0 ;
9230 void *argp1 = 0 ;
9231 int res1 = 0 ;
9232 PyObject *swig_obj[1] ;
9233
9234 if (!args) SWIG_fail;
9235 swig_obj[0] = args;
9236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9237 if (!SWIG_IsOK(res1)) {
9238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9239 }
9240 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9241 {
9242 delete arg1;
9243
9244 if (PyErr_Occurred()) SWIG_fail;
9245 }
9246 resultobj = SWIG_Py_Void();
9247 return resultobj;
9248 fail:
9249 return NULL;
9250 }
9251
9252
9253 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9254 PyObject *resultobj = 0;
9255 wxRect2D *arg1 = (wxRect2D *) 0 ;
9256 wxPoint2D result;
9257 void *argp1 = 0 ;
9258 int res1 = 0 ;
9259 PyObject *swig_obj[1] ;
9260
9261 if (!args) SWIG_fail;
9262 swig_obj[0] = args;
9263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9264 if (!SWIG_IsOK(res1)) {
9265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9266 }
9267 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9268 {
9269 result = (arg1)->GetPosition();
9270 if (PyErr_Occurred()) SWIG_fail;
9271 }
9272 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9273 return resultobj;
9274 fail:
9275 return NULL;
9276 }
9277
9278
9279 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9280 PyObject *resultobj = 0;
9281 wxRect2D *arg1 = (wxRect2D *) 0 ;
9282 wxSize result;
9283 void *argp1 = 0 ;
9284 int res1 = 0 ;
9285 PyObject *swig_obj[1] ;
9286
9287 if (!args) SWIG_fail;
9288 swig_obj[0] = args;
9289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9290 if (!SWIG_IsOK(res1)) {
9291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9292 }
9293 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9294 {
9295 result = (arg1)->GetSize();
9296 if (PyErr_Occurred()) SWIG_fail;
9297 }
9298 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9299 return resultobj;
9300 fail:
9301 return NULL;
9302 }
9303
9304
9305 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9306 PyObject *resultobj = 0;
9307 wxRect2D *arg1 = (wxRect2D *) 0 ;
9308 wxDouble result;
9309 void *argp1 = 0 ;
9310 int res1 = 0 ;
9311 PyObject *swig_obj[1] ;
9312
9313 if (!args) SWIG_fail;
9314 swig_obj[0] = args;
9315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9316 if (!SWIG_IsOK(res1)) {
9317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9318 }
9319 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9320 {
9321 result = ((wxRect2D const *)arg1)->GetLeft();
9322 if (PyErr_Occurred()) SWIG_fail;
9323 }
9324 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9325 return resultobj;
9326 fail:
9327 return NULL;
9328 }
9329
9330
9331 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9332 PyObject *resultobj = 0;
9333 wxRect2D *arg1 = (wxRect2D *) 0 ;
9334 wxDouble arg2 ;
9335 void *argp1 = 0 ;
9336 int res1 = 0 ;
9337 void *argp2 ;
9338 int res2 = 0 ;
9339 PyObject * obj0 = 0 ;
9340 PyObject * obj1 = 0 ;
9341 char * kwnames[] = {
9342 (char *) "self",(char *) "n", NULL
9343 };
9344
9345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9347 if (!SWIG_IsOK(res1)) {
9348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9349 }
9350 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9351 {
9352 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9353 if (!SWIG_IsOK(res2)) {
9354 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9355 }
9356 if (!argp2) {
9357 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9358 } else {
9359 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9360 arg2 = *temp;
9361 if (SWIG_IsNewObj(res2)) delete temp;
9362 }
9363 }
9364 {
9365 (arg1)->SetLeft(arg2);
9366 if (PyErr_Occurred()) SWIG_fail;
9367 }
9368 resultobj = SWIG_Py_Void();
9369 return resultobj;
9370 fail:
9371 return NULL;
9372 }
9373
9374
9375 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9376 PyObject *resultobj = 0;
9377 wxRect2D *arg1 = (wxRect2D *) 0 ;
9378 wxDouble arg2 ;
9379 void *argp1 = 0 ;
9380 int res1 = 0 ;
9381 void *argp2 ;
9382 int res2 = 0 ;
9383 PyObject * obj0 = 0 ;
9384 PyObject * obj1 = 0 ;
9385 char * kwnames[] = {
9386 (char *) "self",(char *) "n", NULL
9387 };
9388
9389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9391 if (!SWIG_IsOK(res1)) {
9392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9393 }
9394 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9395 {
9396 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9397 if (!SWIG_IsOK(res2)) {
9398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9399 }
9400 if (!argp2) {
9401 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9402 } else {
9403 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9404 arg2 = *temp;
9405 if (SWIG_IsNewObj(res2)) delete temp;
9406 }
9407 }
9408 {
9409 (arg1)->MoveLeftTo(arg2);
9410 if (PyErr_Occurred()) SWIG_fail;
9411 }
9412 resultobj = SWIG_Py_Void();
9413 return resultobj;
9414 fail:
9415 return NULL;
9416 }
9417
9418
9419 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9420 PyObject *resultobj = 0;
9421 wxRect2D *arg1 = (wxRect2D *) 0 ;
9422 wxDouble result;
9423 void *argp1 = 0 ;
9424 int res1 = 0 ;
9425 PyObject *swig_obj[1] ;
9426
9427 if (!args) SWIG_fail;
9428 swig_obj[0] = args;
9429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9430 if (!SWIG_IsOK(res1)) {
9431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9432 }
9433 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9434 {
9435 result = ((wxRect2D const *)arg1)->GetTop();
9436 if (PyErr_Occurred()) SWIG_fail;
9437 }
9438 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9439 return resultobj;
9440 fail:
9441 return NULL;
9442 }
9443
9444
9445 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9446 PyObject *resultobj = 0;
9447 wxRect2D *arg1 = (wxRect2D *) 0 ;
9448 wxDouble arg2 ;
9449 void *argp1 = 0 ;
9450 int res1 = 0 ;
9451 void *argp2 ;
9452 int res2 = 0 ;
9453 PyObject * obj0 = 0 ;
9454 PyObject * obj1 = 0 ;
9455 char * kwnames[] = {
9456 (char *) "self",(char *) "n", NULL
9457 };
9458
9459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9461 if (!SWIG_IsOK(res1)) {
9462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9463 }
9464 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9465 {
9466 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9467 if (!SWIG_IsOK(res2)) {
9468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9469 }
9470 if (!argp2) {
9471 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9472 } else {
9473 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9474 arg2 = *temp;
9475 if (SWIG_IsNewObj(res2)) delete temp;
9476 }
9477 }
9478 {
9479 (arg1)->SetTop(arg2);
9480 if (PyErr_Occurred()) SWIG_fail;
9481 }
9482 resultobj = SWIG_Py_Void();
9483 return resultobj;
9484 fail:
9485 return NULL;
9486 }
9487
9488
9489 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9490 PyObject *resultobj = 0;
9491 wxRect2D *arg1 = (wxRect2D *) 0 ;
9492 wxDouble arg2 ;
9493 void *argp1 = 0 ;
9494 int res1 = 0 ;
9495 void *argp2 ;
9496 int res2 = 0 ;
9497 PyObject * obj0 = 0 ;
9498 PyObject * obj1 = 0 ;
9499 char * kwnames[] = {
9500 (char *) "self",(char *) "n", NULL
9501 };
9502
9503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9505 if (!SWIG_IsOK(res1)) {
9506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9507 }
9508 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9509 {
9510 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9511 if (!SWIG_IsOK(res2)) {
9512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9513 }
9514 if (!argp2) {
9515 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9516 } else {
9517 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9518 arg2 = *temp;
9519 if (SWIG_IsNewObj(res2)) delete temp;
9520 }
9521 }
9522 {
9523 (arg1)->MoveTopTo(arg2);
9524 if (PyErr_Occurred()) SWIG_fail;
9525 }
9526 resultobj = SWIG_Py_Void();
9527 return resultobj;
9528 fail:
9529 return NULL;
9530 }
9531
9532
9533 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9534 PyObject *resultobj = 0;
9535 wxRect2D *arg1 = (wxRect2D *) 0 ;
9536 wxDouble result;
9537 void *argp1 = 0 ;
9538 int res1 = 0 ;
9539 PyObject *swig_obj[1] ;
9540
9541 if (!args) SWIG_fail;
9542 swig_obj[0] = args;
9543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9544 if (!SWIG_IsOK(res1)) {
9545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9546 }
9547 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9548 {
9549 result = ((wxRect2D const *)arg1)->GetBottom();
9550 if (PyErr_Occurred()) SWIG_fail;
9551 }
9552 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9553 return resultobj;
9554 fail:
9555 return NULL;
9556 }
9557
9558
9559 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9560 PyObject *resultobj = 0;
9561 wxRect2D *arg1 = (wxRect2D *) 0 ;
9562 wxDouble arg2 ;
9563 void *argp1 = 0 ;
9564 int res1 = 0 ;
9565 void *argp2 ;
9566 int res2 = 0 ;
9567 PyObject * obj0 = 0 ;
9568 PyObject * obj1 = 0 ;
9569 char * kwnames[] = {
9570 (char *) "self",(char *) "n", NULL
9571 };
9572
9573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9575 if (!SWIG_IsOK(res1)) {
9576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9577 }
9578 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9579 {
9580 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9581 if (!SWIG_IsOK(res2)) {
9582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9583 }
9584 if (!argp2) {
9585 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9586 } else {
9587 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9588 arg2 = *temp;
9589 if (SWIG_IsNewObj(res2)) delete temp;
9590 }
9591 }
9592 {
9593 (arg1)->SetBottom(arg2);
9594 if (PyErr_Occurred()) SWIG_fail;
9595 }
9596 resultobj = SWIG_Py_Void();
9597 return resultobj;
9598 fail:
9599 return NULL;
9600 }
9601
9602
9603 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9604 PyObject *resultobj = 0;
9605 wxRect2D *arg1 = (wxRect2D *) 0 ;
9606 wxDouble arg2 ;
9607 void *argp1 = 0 ;
9608 int res1 = 0 ;
9609 void *argp2 ;
9610 int res2 = 0 ;
9611 PyObject * obj0 = 0 ;
9612 PyObject * obj1 = 0 ;
9613 char * kwnames[] = {
9614 (char *) "self",(char *) "n", NULL
9615 };
9616
9617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9619 if (!SWIG_IsOK(res1)) {
9620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9621 }
9622 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9623 {
9624 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9625 if (!SWIG_IsOK(res2)) {
9626 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9627 }
9628 if (!argp2) {
9629 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9630 } else {
9631 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9632 arg2 = *temp;
9633 if (SWIG_IsNewObj(res2)) delete temp;
9634 }
9635 }
9636 {
9637 (arg1)->MoveBottomTo(arg2);
9638 if (PyErr_Occurred()) SWIG_fail;
9639 }
9640 resultobj = SWIG_Py_Void();
9641 return resultobj;
9642 fail:
9643 return NULL;
9644 }
9645
9646
9647 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9648 PyObject *resultobj = 0;
9649 wxRect2D *arg1 = (wxRect2D *) 0 ;
9650 wxDouble result;
9651 void *argp1 = 0 ;
9652 int res1 = 0 ;
9653 PyObject *swig_obj[1] ;
9654
9655 if (!args) SWIG_fail;
9656 swig_obj[0] = args;
9657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9658 if (!SWIG_IsOK(res1)) {
9659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9660 }
9661 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9662 {
9663 result = ((wxRect2D const *)arg1)->GetRight();
9664 if (PyErr_Occurred()) SWIG_fail;
9665 }
9666 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9667 return resultobj;
9668 fail:
9669 return NULL;
9670 }
9671
9672
9673 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9674 PyObject *resultobj = 0;
9675 wxRect2D *arg1 = (wxRect2D *) 0 ;
9676 wxDouble arg2 ;
9677 void *argp1 = 0 ;
9678 int res1 = 0 ;
9679 void *argp2 ;
9680 int res2 = 0 ;
9681 PyObject * obj0 = 0 ;
9682 PyObject * obj1 = 0 ;
9683 char * kwnames[] = {
9684 (char *) "self",(char *) "n", NULL
9685 };
9686
9687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9689 if (!SWIG_IsOK(res1)) {
9690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9691 }
9692 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9693 {
9694 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9695 if (!SWIG_IsOK(res2)) {
9696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9697 }
9698 if (!argp2) {
9699 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9700 } else {
9701 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9702 arg2 = *temp;
9703 if (SWIG_IsNewObj(res2)) delete temp;
9704 }
9705 }
9706 {
9707 (arg1)->SetRight(arg2);
9708 if (PyErr_Occurred()) SWIG_fail;
9709 }
9710 resultobj = SWIG_Py_Void();
9711 return resultobj;
9712 fail:
9713 return NULL;
9714 }
9715
9716
9717 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9718 PyObject *resultobj = 0;
9719 wxRect2D *arg1 = (wxRect2D *) 0 ;
9720 wxDouble arg2 ;
9721 void *argp1 = 0 ;
9722 int res1 = 0 ;
9723 void *argp2 ;
9724 int res2 = 0 ;
9725 PyObject * obj0 = 0 ;
9726 PyObject * obj1 = 0 ;
9727 char * kwnames[] = {
9728 (char *) "self",(char *) "n", NULL
9729 };
9730
9731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9733 if (!SWIG_IsOK(res1)) {
9734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9735 }
9736 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9737 {
9738 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9739 if (!SWIG_IsOK(res2)) {
9740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9741 }
9742 if (!argp2) {
9743 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9744 } else {
9745 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9746 arg2 = *temp;
9747 if (SWIG_IsNewObj(res2)) delete temp;
9748 }
9749 }
9750 {
9751 (arg1)->MoveRightTo(arg2);
9752 if (PyErr_Occurred()) SWIG_fail;
9753 }
9754 resultobj = SWIG_Py_Void();
9755 return resultobj;
9756 fail:
9757 return NULL;
9758 }
9759
9760
9761 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9762 PyObject *resultobj = 0;
9763 wxRect2D *arg1 = (wxRect2D *) 0 ;
9764 wxPoint2D result;
9765 void *argp1 = 0 ;
9766 int res1 = 0 ;
9767 PyObject *swig_obj[1] ;
9768
9769 if (!args) SWIG_fail;
9770 swig_obj[0] = args;
9771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9772 if (!SWIG_IsOK(res1)) {
9773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9774 }
9775 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9776 {
9777 result = ((wxRect2D const *)arg1)->GetLeftTop();
9778 if (PyErr_Occurred()) SWIG_fail;
9779 }
9780 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9781 return resultobj;
9782 fail:
9783 return NULL;
9784 }
9785
9786
9787 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9788 PyObject *resultobj = 0;
9789 wxRect2D *arg1 = (wxRect2D *) 0 ;
9790 wxPoint2D *arg2 = 0 ;
9791 void *argp1 = 0 ;
9792 int res1 = 0 ;
9793 wxPoint2D temp2 ;
9794 PyObject * obj0 = 0 ;
9795 PyObject * obj1 = 0 ;
9796 char * kwnames[] = {
9797 (char *) "self",(char *) "pt", NULL
9798 };
9799
9800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9802 if (!SWIG_IsOK(res1)) {
9803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9804 }
9805 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9806 {
9807 arg2 = &temp2;
9808 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9809 }
9810 {
9811 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9812 if (PyErr_Occurred()) SWIG_fail;
9813 }
9814 resultobj = SWIG_Py_Void();
9815 return resultobj;
9816 fail:
9817 return NULL;
9818 }
9819
9820
9821 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9822 PyObject *resultobj = 0;
9823 wxRect2D *arg1 = (wxRect2D *) 0 ;
9824 wxPoint2D *arg2 = 0 ;
9825 void *argp1 = 0 ;
9826 int res1 = 0 ;
9827 wxPoint2D temp2 ;
9828 PyObject * obj0 = 0 ;
9829 PyObject * obj1 = 0 ;
9830 char * kwnames[] = {
9831 (char *) "self",(char *) "pt", NULL
9832 };
9833
9834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9836 if (!SWIG_IsOK(res1)) {
9837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9838 }
9839 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9840 {
9841 arg2 = &temp2;
9842 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9843 }
9844 {
9845 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9846 if (PyErr_Occurred()) SWIG_fail;
9847 }
9848 resultobj = SWIG_Py_Void();
9849 return resultobj;
9850 fail:
9851 return NULL;
9852 }
9853
9854
9855 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9856 PyObject *resultobj = 0;
9857 wxRect2D *arg1 = (wxRect2D *) 0 ;
9858 wxPoint2D result;
9859 void *argp1 = 0 ;
9860 int res1 = 0 ;
9861 PyObject *swig_obj[1] ;
9862
9863 if (!args) SWIG_fail;
9864 swig_obj[0] = args;
9865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9866 if (!SWIG_IsOK(res1)) {
9867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9868 }
9869 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9870 {
9871 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9872 if (PyErr_Occurred()) SWIG_fail;
9873 }
9874 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9875 return resultobj;
9876 fail:
9877 return NULL;
9878 }
9879
9880
9881 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9882 PyObject *resultobj = 0;
9883 wxRect2D *arg1 = (wxRect2D *) 0 ;
9884 wxPoint2D *arg2 = 0 ;
9885 void *argp1 = 0 ;
9886 int res1 = 0 ;
9887 wxPoint2D temp2 ;
9888 PyObject * obj0 = 0 ;
9889 PyObject * obj1 = 0 ;
9890 char * kwnames[] = {
9891 (char *) "self",(char *) "pt", NULL
9892 };
9893
9894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9896 if (!SWIG_IsOK(res1)) {
9897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9898 }
9899 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9900 {
9901 arg2 = &temp2;
9902 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9903 }
9904 {
9905 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9906 if (PyErr_Occurred()) SWIG_fail;
9907 }
9908 resultobj = SWIG_Py_Void();
9909 return resultobj;
9910 fail:
9911 return NULL;
9912 }
9913
9914
9915 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9916 PyObject *resultobj = 0;
9917 wxRect2D *arg1 = (wxRect2D *) 0 ;
9918 wxPoint2D *arg2 = 0 ;
9919 void *argp1 = 0 ;
9920 int res1 = 0 ;
9921 wxPoint2D temp2 ;
9922 PyObject * obj0 = 0 ;
9923 PyObject * obj1 = 0 ;
9924 char * kwnames[] = {
9925 (char *) "self",(char *) "pt", NULL
9926 };
9927
9928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9930 if (!SWIG_IsOK(res1)) {
9931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9932 }
9933 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9934 {
9935 arg2 = &temp2;
9936 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9937 }
9938 {
9939 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
9940 if (PyErr_Occurred()) SWIG_fail;
9941 }
9942 resultobj = SWIG_Py_Void();
9943 return resultobj;
9944 fail:
9945 return NULL;
9946 }
9947
9948
9949 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9950 PyObject *resultobj = 0;
9951 wxRect2D *arg1 = (wxRect2D *) 0 ;
9952 wxPoint2D result;
9953 void *argp1 = 0 ;
9954 int res1 = 0 ;
9955 PyObject *swig_obj[1] ;
9956
9957 if (!args) SWIG_fail;
9958 swig_obj[0] = args;
9959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9960 if (!SWIG_IsOK(res1)) {
9961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9962 }
9963 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9964 {
9965 result = ((wxRect2D const *)arg1)->GetRightTop();
9966 if (PyErr_Occurred()) SWIG_fail;
9967 }
9968 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9969 return resultobj;
9970 fail:
9971 return NULL;
9972 }
9973
9974
9975 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9976 PyObject *resultobj = 0;
9977 wxRect2D *arg1 = (wxRect2D *) 0 ;
9978 wxPoint2D *arg2 = 0 ;
9979 void *argp1 = 0 ;
9980 int res1 = 0 ;
9981 wxPoint2D temp2 ;
9982 PyObject * obj0 = 0 ;
9983 PyObject * obj1 = 0 ;
9984 char * kwnames[] = {
9985 (char *) "self",(char *) "pt", NULL
9986 };
9987
9988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
9989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9990 if (!SWIG_IsOK(res1)) {
9991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9992 }
9993 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9994 {
9995 arg2 = &temp2;
9996 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9997 }
9998 {
9999 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
10000 if (PyErr_Occurred()) SWIG_fail;
10001 }
10002 resultobj = SWIG_Py_Void();
10003 return resultobj;
10004 fail:
10005 return NULL;
10006 }
10007
10008
10009 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10010 PyObject *resultobj = 0;
10011 wxRect2D *arg1 = (wxRect2D *) 0 ;
10012 wxPoint2D *arg2 = 0 ;
10013 void *argp1 = 0 ;
10014 int res1 = 0 ;
10015 wxPoint2D temp2 ;
10016 PyObject * obj0 = 0 ;
10017 PyObject * obj1 = 0 ;
10018 char * kwnames[] = {
10019 (char *) "self",(char *) "pt", NULL
10020 };
10021
10022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10024 if (!SWIG_IsOK(res1)) {
10025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10026 }
10027 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10028 {
10029 arg2 = &temp2;
10030 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10031 }
10032 {
10033 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10034 if (PyErr_Occurred()) SWIG_fail;
10035 }
10036 resultobj = SWIG_Py_Void();
10037 return resultobj;
10038 fail:
10039 return NULL;
10040 }
10041
10042
10043 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10044 PyObject *resultobj = 0;
10045 wxRect2D *arg1 = (wxRect2D *) 0 ;
10046 wxPoint2D result;
10047 void *argp1 = 0 ;
10048 int res1 = 0 ;
10049 PyObject *swig_obj[1] ;
10050
10051 if (!args) SWIG_fail;
10052 swig_obj[0] = args;
10053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10054 if (!SWIG_IsOK(res1)) {
10055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10056 }
10057 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10058 {
10059 result = ((wxRect2D const *)arg1)->GetRightBottom();
10060 if (PyErr_Occurred()) SWIG_fail;
10061 }
10062 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10063 return resultobj;
10064 fail:
10065 return NULL;
10066 }
10067
10068
10069 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10070 PyObject *resultobj = 0;
10071 wxRect2D *arg1 = (wxRect2D *) 0 ;
10072 wxPoint2D *arg2 = 0 ;
10073 void *argp1 = 0 ;
10074 int res1 = 0 ;
10075 wxPoint2D temp2 ;
10076 PyObject * obj0 = 0 ;
10077 PyObject * obj1 = 0 ;
10078 char * kwnames[] = {
10079 (char *) "self",(char *) "pt", NULL
10080 };
10081
10082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10084 if (!SWIG_IsOK(res1)) {
10085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10086 }
10087 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10088 {
10089 arg2 = &temp2;
10090 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10091 }
10092 {
10093 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10094 if (PyErr_Occurred()) SWIG_fail;
10095 }
10096 resultobj = SWIG_Py_Void();
10097 return resultobj;
10098 fail:
10099 return NULL;
10100 }
10101
10102
10103 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10104 PyObject *resultobj = 0;
10105 wxRect2D *arg1 = (wxRect2D *) 0 ;
10106 wxPoint2D *arg2 = 0 ;
10107 void *argp1 = 0 ;
10108 int res1 = 0 ;
10109 wxPoint2D temp2 ;
10110 PyObject * obj0 = 0 ;
10111 PyObject * obj1 = 0 ;
10112 char * kwnames[] = {
10113 (char *) "self",(char *) "pt", NULL
10114 };
10115
10116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10118 if (!SWIG_IsOK(res1)) {
10119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10120 }
10121 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10122 {
10123 arg2 = &temp2;
10124 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10125 }
10126 {
10127 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10128 if (PyErr_Occurred()) SWIG_fail;
10129 }
10130 resultobj = SWIG_Py_Void();
10131 return resultobj;
10132 fail:
10133 return NULL;
10134 }
10135
10136
10137 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10138 PyObject *resultobj = 0;
10139 wxRect2D *arg1 = (wxRect2D *) 0 ;
10140 wxPoint2D result;
10141 void *argp1 = 0 ;
10142 int res1 = 0 ;
10143 PyObject *swig_obj[1] ;
10144
10145 if (!args) SWIG_fail;
10146 swig_obj[0] = args;
10147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10148 if (!SWIG_IsOK(res1)) {
10149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10150 }
10151 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10152 {
10153 result = ((wxRect2D const *)arg1)->GetCentre();
10154 if (PyErr_Occurred()) SWIG_fail;
10155 }
10156 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10157 return resultobj;
10158 fail:
10159 return NULL;
10160 }
10161
10162
10163 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10164 PyObject *resultobj = 0;
10165 wxRect2D *arg1 = (wxRect2D *) 0 ;
10166 wxPoint2D *arg2 = 0 ;
10167 void *argp1 = 0 ;
10168 int res1 = 0 ;
10169 wxPoint2D temp2 ;
10170 PyObject * obj0 = 0 ;
10171 PyObject * obj1 = 0 ;
10172 char * kwnames[] = {
10173 (char *) "self",(char *) "pt", NULL
10174 };
10175
10176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10178 if (!SWIG_IsOK(res1)) {
10179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10180 }
10181 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10182 {
10183 arg2 = &temp2;
10184 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10185 }
10186 {
10187 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10188 if (PyErr_Occurred()) SWIG_fail;
10189 }
10190 resultobj = SWIG_Py_Void();
10191 return resultobj;
10192 fail:
10193 return NULL;
10194 }
10195
10196
10197 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10198 PyObject *resultobj = 0;
10199 wxRect2D *arg1 = (wxRect2D *) 0 ;
10200 wxPoint2D *arg2 = 0 ;
10201 void *argp1 = 0 ;
10202 int res1 = 0 ;
10203 wxPoint2D temp2 ;
10204 PyObject * obj0 = 0 ;
10205 PyObject * obj1 = 0 ;
10206 char * kwnames[] = {
10207 (char *) "self",(char *) "pt", NULL
10208 };
10209
10210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10212 if (!SWIG_IsOK(res1)) {
10213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10214 }
10215 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10216 {
10217 arg2 = &temp2;
10218 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10219 }
10220 {
10221 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10222 if (PyErr_Occurred()) SWIG_fail;
10223 }
10224 resultobj = SWIG_Py_Void();
10225 return resultobj;
10226 fail:
10227 return NULL;
10228 }
10229
10230
10231 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10232 PyObject *resultobj = 0;
10233 wxRect2D *arg1 = (wxRect2D *) 0 ;
10234 wxPoint2D *arg2 = 0 ;
10235 wxOutCode result;
10236 void *argp1 = 0 ;
10237 int res1 = 0 ;
10238 wxPoint2D temp2 ;
10239 PyObject * obj0 = 0 ;
10240 PyObject * obj1 = 0 ;
10241 char * kwnames[] = {
10242 (char *) "self",(char *) "pt", NULL
10243 };
10244
10245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10247 if (!SWIG_IsOK(res1)) {
10248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10249 }
10250 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10251 {
10252 arg2 = &temp2;
10253 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10254 }
10255 {
10256 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10257 if (PyErr_Occurred()) SWIG_fail;
10258 }
10259 resultobj = SWIG_From_int(static_cast< int >(result));
10260 return resultobj;
10261 fail:
10262 return NULL;
10263 }
10264
10265
10266 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10267 PyObject *resultobj = 0;
10268 wxRect2D *arg1 = (wxRect2D *) 0 ;
10269 wxPoint2D *arg2 = 0 ;
10270 bool result;
10271 void *argp1 = 0 ;
10272 int res1 = 0 ;
10273 wxPoint2D temp2 ;
10274 PyObject * obj0 = 0 ;
10275 PyObject * obj1 = 0 ;
10276 char * kwnames[] = {
10277 (char *) "self",(char *) "pt", NULL
10278 };
10279
10280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10282 if (!SWIG_IsOK(res1)) {
10283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10284 }
10285 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10286 {
10287 arg2 = &temp2;
10288 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10289 }
10290 {
10291 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10292 if (PyErr_Occurred()) SWIG_fail;
10293 }
10294 {
10295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10296 }
10297 return resultobj;
10298 fail:
10299 return NULL;
10300 }
10301
10302
10303 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10304 PyObject *resultobj = 0;
10305 wxRect2D *arg1 = (wxRect2D *) 0 ;
10306 wxRect2D *arg2 = 0 ;
10307 bool result;
10308 void *argp1 = 0 ;
10309 int res1 = 0 ;
10310 wxRect2D temp2 ;
10311 PyObject * obj0 = 0 ;
10312 PyObject * obj1 = 0 ;
10313 char * kwnames[] = {
10314 (char *) "self",(char *) "rect", NULL
10315 };
10316
10317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10319 if (!SWIG_IsOK(res1)) {
10320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10321 }
10322 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10323 {
10324 arg2 = &temp2;
10325 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10326 }
10327 {
10328 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10329 if (PyErr_Occurred()) SWIG_fail;
10330 }
10331 {
10332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10333 }
10334 return resultobj;
10335 fail:
10336 return NULL;
10337 }
10338
10339
10340 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10341 PyObject *resultobj = 0;
10342 wxRect2D *arg1 = (wxRect2D *) 0 ;
10343 bool result;
10344 void *argp1 = 0 ;
10345 int res1 = 0 ;
10346 PyObject *swig_obj[1] ;
10347
10348 if (!args) SWIG_fail;
10349 swig_obj[0] = args;
10350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10351 if (!SWIG_IsOK(res1)) {
10352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10353 }
10354 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10355 {
10356 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10357 if (PyErr_Occurred()) SWIG_fail;
10358 }
10359 {
10360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10361 }
10362 return resultobj;
10363 fail:
10364 return NULL;
10365 }
10366
10367
10368 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10369 PyObject *resultobj = 0;
10370 wxRect2D *arg1 = (wxRect2D *) 0 ;
10371 wxRect2D *arg2 = 0 ;
10372 bool result;
10373 void *argp1 = 0 ;
10374 int res1 = 0 ;
10375 wxRect2D temp2 ;
10376 PyObject * obj0 = 0 ;
10377 PyObject * obj1 = 0 ;
10378 char * kwnames[] = {
10379 (char *) "self",(char *) "rect", NULL
10380 };
10381
10382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10384 if (!SWIG_IsOK(res1)) {
10385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10386 }
10387 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10388 {
10389 arg2 = &temp2;
10390 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10391 }
10392 {
10393 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10394 if (PyErr_Occurred()) SWIG_fail;
10395 }
10396 {
10397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10398 }
10399 return resultobj;
10400 fail:
10401 return NULL;
10402 }
10403
10404
10405 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10406 PyObject *resultobj = 0;
10407 wxRect2D *arg1 = (wxRect2D *) 0 ;
10408 wxDouble arg2 ;
10409 wxDouble arg3 ;
10410 void *argp1 = 0 ;
10411 int res1 = 0 ;
10412 void *argp2 ;
10413 int res2 = 0 ;
10414 void *argp3 ;
10415 int res3 = 0 ;
10416
10417 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10419 if (!SWIG_IsOK(res1)) {
10420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10421 }
10422 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10423 {
10424 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10425 if (!SWIG_IsOK(res2)) {
10426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10427 }
10428 if (!argp2) {
10429 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10430 } else {
10431 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10432 arg2 = *temp;
10433 if (SWIG_IsNewObj(res2)) delete temp;
10434 }
10435 }
10436 {
10437 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10438 if (!SWIG_IsOK(res3)) {
10439 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10440 }
10441 if (!argp3) {
10442 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10443 } else {
10444 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10445 arg3 = *temp;
10446 if (SWIG_IsNewObj(res3)) delete temp;
10447 }
10448 }
10449 {
10450 (arg1)->Inset(arg2,arg3);
10451 if (PyErr_Occurred()) SWIG_fail;
10452 }
10453 resultobj = SWIG_Py_Void();
10454 return resultobj;
10455 fail:
10456 return NULL;
10457 }
10458
10459
10460 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10461 PyObject *resultobj = 0;
10462 wxRect2D *arg1 = (wxRect2D *) 0 ;
10463 wxDouble arg2 ;
10464 wxDouble arg3 ;
10465 wxDouble arg4 ;
10466 wxDouble arg5 ;
10467 void *argp1 = 0 ;
10468 int res1 = 0 ;
10469 void *argp2 ;
10470 int res2 = 0 ;
10471 void *argp3 ;
10472 int res3 = 0 ;
10473 void *argp4 ;
10474 int res4 = 0 ;
10475 void *argp5 ;
10476 int res5 = 0 ;
10477
10478 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10480 if (!SWIG_IsOK(res1)) {
10481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10482 }
10483 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10484 {
10485 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10486 if (!SWIG_IsOK(res2)) {
10487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10488 }
10489 if (!argp2) {
10490 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10491 } else {
10492 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10493 arg2 = *temp;
10494 if (SWIG_IsNewObj(res2)) delete temp;
10495 }
10496 }
10497 {
10498 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10499 if (!SWIG_IsOK(res3)) {
10500 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10501 }
10502 if (!argp3) {
10503 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10504 } else {
10505 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10506 arg3 = *temp;
10507 if (SWIG_IsNewObj(res3)) delete temp;
10508 }
10509 }
10510 {
10511 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10512 if (!SWIG_IsOK(res4)) {
10513 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10514 }
10515 if (!argp4) {
10516 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10517 } else {
10518 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10519 arg4 = *temp;
10520 if (SWIG_IsNewObj(res4)) delete temp;
10521 }
10522 }
10523 {
10524 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10525 if (!SWIG_IsOK(res5)) {
10526 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10527 }
10528 if (!argp5) {
10529 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10530 } else {
10531 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10532 arg5 = *temp;
10533 if (SWIG_IsNewObj(res5)) delete temp;
10534 }
10535 }
10536 {
10537 (arg1)->Inset(arg2,arg3,arg4,arg5);
10538 if (PyErr_Occurred()) SWIG_fail;
10539 }
10540 resultobj = SWIG_Py_Void();
10541 return resultobj;
10542 fail:
10543 return NULL;
10544 }
10545
10546
10547 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10548 int argc;
10549 PyObject *argv[6];
10550
10551 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10552 --argc;
10553 if (argc == 3) {
10554 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10555 }
10556 if (argc == 5) {
10557 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10558 }
10559
10560 fail:
10561 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10562 return NULL;
10563 }
10564
10565
10566 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10567 PyObject *resultobj = 0;
10568 wxRect2D *arg1 = (wxRect2D *) 0 ;
10569 wxPoint2D *arg2 = 0 ;
10570 void *argp1 = 0 ;
10571 int res1 = 0 ;
10572 wxPoint2D temp2 ;
10573 PyObject * obj0 = 0 ;
10574 PyObject * obj1 = 0 ;
10575 char * kwnames[] = {
10576 (char *) "self",(char *) "pt", NULL
10577 };
10578
10579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10581 if (!SWIG_IsOK(res1)) {
10582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10583 }
10584 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10585 {
10586 arg2 = &temp2;
10587 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10588 }
10589 {
10590 (arg1)->Offset((wxPoint2D const &)*arg2);
10591 if (PyErr_Occurred()) SWIG_fail;
10592 }
10593 resultobj = SWIG_Py_Void();
10594 return resultobj;
10595 fail:
10596 return NULL;
10597 }
10598
10599
10600 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10601 PyObject *resultobj = 0;
10602 wxRect2D *arg1 = (wxRect2D *) 0 ;
10603 wxRect2D *arg2 = 0 ;
10604 void *argp1 = 0 ;
10605 int res1 = 0 ;
10606 wxRect2D temp2 ;
10607 PyObject * obj0 = 0 ;
10608 PyObject * obj1 = 0 ;
10609 char * kwnames[] = {
10610 (char *) "self",(char *) "rect", NULL
10611 };
10612
10613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10615 if (!SWIG_IsOK(res1)) {
10616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10617 }
10618 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10619 {
10620 arg2 = &temp2;
10621 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10622 }
10623 {
10624 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10625 if (PyErr_Occurred()) SWIG_fail;
10626 }
10627 resultobj = SWIG_Py_Void();
10628 return resultobj;
10629 fail:
10630 return NULL;
10631 }
10632
10633
10634 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10635 PyObject *resultobj = 0;
10636 wxRect2D *arg1 = (wxRect2D *) 0 ;
10637 int arg2 ;
10638 int arg3 ;
10639 wxPoint2D result;
10640 void *argp1 = 0 ;
10641 int res1 = 0 ;
10642 int val2 ;
10643 int ecode2 = 0 ;
10644 int val3 ;
10645 int ecode3 = 0 ;
10646 PyObject * obj0 = 0 ;
10647 PyObject * obj1 = 0 ;
10648 PyObject * obj2 = 0 ;
10649 char * kwnames[] = {
10650 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10651 };
10652
10653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10655 if (!SWIG_IsOK(res1)) {
10656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10657 }
10658 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10659 ecode2 = SWIG_AsVal_int(obj1, &val2);
10660 if (!SWIG_IsOK(ecode2)) {
10661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10662 }
10663 arg2 = static_cast< int >(val2);
10664 ecode3 = SWIG_AsVal_int(obj2, &val3);
10665 if (!SWIG_IsOK(ecode3)) {
10666 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10667 }
10668 arg3 = static_cast< int >(val3);
10669 {
10670 result = (arg1)->Interpolate(arg2,arg3);
10671 if (PyErr_Occurred()) SWIG_fail;
10672 }
10673 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10674 return resultobj;
10675 fail:
10676 return NULL;
10677 }
10678
10679
10680 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10681 PyObject *resultobj = 0;
10682 wxRect2D *arg1 = (wxRect2D *) 0 ;
10683 wxRect2D *arg2 = 0 ;
10684 void *argp1 = 0 ;
10685 int res1 = 0 ;
10686 wxRect2D temp2 ;
10687 PyObject * obj0 = 0 ;
10688 PyObject * obj1 = 0 ;
10689 char * kwnames[] = {
10690 (char *) "self",(char *) "otherRect", NULL
10691 };
10692
10693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10695 if (!SWIG_IsOK(res1)) {
10696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10697 }
10698 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10699 {
10700 arg2 = &temp2;
10701 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10702 }
10703 {
10704 (arg1)->Intersect((wxRect2D const &)*arg2);
10705 if (PyErr_Occurred()) SWIG_fail;
10706 }
10707 resultobj = SWIG_Py_Void();
10708 return resultobj;
10709 fail:
10710 return NULL;
10711 }
10712
10713
10714 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10715 PyObject *resultobj = 0;
10716 wxRect2D *arg1 = (wxRect2D *) 0 ;
10717 wxRect2D *arg2 = 0 ;
10718 wxRect2D result;
10719 void *argp1 = 0 ;
10720 int res1 = 0 ;
10721 wxRect2D temp2 ;
10722 PyObject * obj0 = 0 ;
10723 PyObject * obj1 = 0 ;
10724 char * kwnames[] = {
10725 (char *) "self",(char *) "otherRect", NULL
10726 };
10727
10728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10730 if (!SWIG_IsOK(res1)) {
10731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10732 }
10733 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10734 {
10735 arg2 = &temp2;
10736 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10737 }
10738 {
10739 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10740 if (PyErr_Occurred()) SWIG_fail;
10741 }
10742 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10743 return resultobj;
10744 fail:
10745 return NULL;
10746 }
10747
10748
10749 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10750 PyObject *resultobj = 0;
10751 wxRect2D *arg1 = (wxRect2D *) 0 ;
10752 wxRect2D *arg2 = 0 ;
10753 bool result;
10754 void *argp1 = 0 ;
10755 int res1 = 0 ;
10756 wxRect2D temp2 ;
10757 PyObject * obj0 = 0 ;
10758 PyObject * obj1 = 0 ;
10759 char * kwnames[] = {
10760 (char *) "self",(char *) "rect", NULL
10761 };
10762
10763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10765 if (!SWIG_IsOK(res1)) {
10766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10767 }
10768 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10769 {
10770 arg2 = &temp2;
10771 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10772 }
10773 {
10774 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10775 if (PyErr_Occurred()) SWIG_fail;
10776 }
10777 {
10778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10779 }
10780 return resultobj;
10781 fail:
10782 return NULL;
10783 }
10784
10785
10786 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10787 PyObject *resultobj = 0;
10788 wxRect2D *arg1 = (wxRect2D *) 0 ;
10789 wxRect2D *arg2 = 0 ;
10790 void *argp1 = 0 ;
10791 int res1 = 0 ;
10792 wxRect2D temp2 ;
10793 PyObject * obj0 = 0 ;
10794 PyObject * obj1 = 0 ;
10795 char * kwnames[] = {
10796 (char *) "self",(char *) "otherRect", NULL
10797 };
10798
10799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10801 if (!SWIG_IsOK(res1)) {
10802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10803 }
10804 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10805 {
10806 arg2 = &temp2;
10807 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10808 }
10809 {
10810 (arg1)->Union((wxRect2D const &)*arg2);
10811 if (PyErr_Occurred()) SWIG_fail;
10812 }
10813 resultobj = SWIG_Py_Void();
10814 return resultobj;
10815 fail:
10816 return NULL;
10817 }
10818
10819
10820 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10821 PyObject *resultobj = 0;
10822 wxRect2D *arg1 = (wxRect2D *) 0 ;
10823 wxRect2D *arg2 = 0 ;
10824 wxRect2D result;
10825 void *argp1 = 0 ;
10826 int res1 = 0 ;
10827 wxRect2D temp2 ;
10828 PyObject * obj0 = 0 ;
10829 PyObject * obj1 = 0 ;
10830 char * kwnames[] = {
10831 (char *) "self",(char *) "otherRect", NULL
10832 };
10833
10834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10836 if (!SWIG_IsOK(res1)) {
10837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10838 }
10839 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10840 {
10841 arg2 = &temp2;
10842 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10843 }
10844 {
10845 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10846 if (PyErr_Occurred()) SWIG_fail;
10847 }
10848 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10849 return resultobj;
10850 fail:
10851 return NULL;
10852 }
10853
10854
10855 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10856 PyObject *resultobj = 0;
10857 wxRect2D *arg1 = (wxRect2D *) 0 ;
10858 wxDouble arg2 ;
10859 void *argp1 = 0 ;
10860 int res1 = 0 ;
10861 void *argp2 ;
10862 int res2 = 0 ;
10863
10864 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10866 if (!SWIG_IsOK(res1)) {
10867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10868 }
10869 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10870 {
10871 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10872 if (!SWIG_IsOK(res2)) {
10873 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10874 }
10875 if (!argp2) {
10876 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10877 } else {
10878 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10879 arg2 = *temp;
10880 if (SWIG_IsNewObj(res2)) delete temp;
10881 }
10882 }
10883 {
10884 (arg1)->Scale(arg2);
10885 if (PyErr_Occurred()) SWIG_fail;
10886 }
10887 resultobj = SWIG_Py_Void();
10888 return resultobj;
10889 fail:
10890 return NULL;
10891 }
10892
10893
10894 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10895 PyObject *resultobj = 0;
10896 wxRect2D *arg1 = (wxRect2D *) 0 ;
10897 int arg2 ;
10898 int arg3 ;
10899 void *argp1 = 0 ;
10900 int res1 = 0 ;
10901 int val2 ;
10902 int ecode2 = 0 ;
10903 int val3 ;
10904 int ecode3 = 0 ;
10905
10906 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10908 if (!SWIG_IsOK(res1)) {
10909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10910 }
10911 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10912 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10913 if (!SWIG_IsOK(ecode2)) {
10914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10915 }
10916 arg2 = static_cast< int >(val2);
10917 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10918 if (!SWIG_IsOK(ecode3)) {
10919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10920 }
10921 arg3 = static_cast< int >(val3);
10922 {
10923 (arg1)->Scale(arg2,arg3);
10924 if (PyErr_Occurred()) SWIG_fail;
10925 }
10926 resultobj = SWIG_Py_Void();
10927 return resultobj;
10928 fail:
10929 return NULL;
10930 }
10931
10932
10933 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
10934 int argc;
10935 PyObject *argv[4];
10936
10937 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
10938 --argc;
10939 if (argc == 2) {
10940 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
10941 }
10942 if (argc == 3) {
10943 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
10944 }
10945
10946 fail:
10947 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
10948 return NULL;
10949 }
10950
10951
10952 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10953 PyObject *resultobj = 0;
10954 wxRect2D *arg1 = (wxRect2D *) 0 ;
10955 PyObject *arg2 = (PyObject *) 0 ;
10956 bool result;
10957 void *argp1 = 0 ;
10958 int res1 = 0 ;
10959 PyObject * obj0 = 0 ;
10960 PyObject * obj1 = 0 ;
10961 char * kwnames[] = {
10962 (char *) "self",(char *) "other", NULL
10963 };
10964
10965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10967 if (!SWIG_IsOK(res1)) {
10968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10969 }
10970 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10971 arg2 = obj1;
10972 {
10973 result = (bool)wxRect2D___eq__(arg1,arg2);
10974 if (PyErr_Occurred()) SWIG_fail;
10975 }
10976 {
10977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10978 }
10979 return resultobj;
10980 fail:
10981 return NULL;
10982 }
10983
10984
10985 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10986 PyObject *resultobj = 0;
10987 wxRect2D *arg1 = (wxRect2D *) 0 ;
10988 PyObject *arg2 = (PyObject *) 0 ;
10989 bool result;
10990 void *argp1 = 0 ;
10991 int res1 = 0 ;
10992 PyObject * obj0 = 0 ;
10993 PyObject * obj1 = 0 ;
10994 char * kwnames[] = {
10995 (char *) "self",(char *) "other", NULL
10996 };
10997
10998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11000 if (!SWIG_IsOK(res1)) {
11001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11002 }
11003 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11004 arg2 = obj1;
11005 {
11006 result = (bool)wxRect2D___ne__(arg1,arg2);
11007 if (PyErr_Occurred()) SWIG_fail;
11008 }
11009 {
11010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11011 }
11012 return resultobj;
11013 fail:
11014 return NULL;
11015 }
11016
11017
11018 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11019 PyObject *resultobj = 0;
11020 wxRect2D *arg1 = (wxRect2D *) 0 ;
11021 wxDouble arg2 ;
11022 void *argp1 = 0 ;
11023 int res1 = 0 ;
11024 void *argp2 ;
11025 int res2 = 0 ;
11026 PyObject *swig_obj[2] ;
11027
11028 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11030 if (!SWIG_IsOK(res1)) {
11031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11032 }
11033 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11034 {
11035 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11036 if (!SWIG_IsOK(res2)) {
11037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11038 }
11039 if (!argp2) {
11040 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11041 } else {
11042 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11043 arg2 = *temp;
11044 if (SWIG_IsNewObj(res2)) delete temp;
11045 }
11046 }
11047 if (arg1) (arg1)->m_x = arg2;
11048
11049 resultobj = SWIG_Py_Void();
11050 return resultobj;
11051 fail:
11052 return NULL;
11053 }
11054
11055
11056 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11057 PyObject *resultobj = 0;
11058 wxRect2D *arg1 = (wxRect2D *) 0 ;
11059 wxDouble result;
11060 void *argp1 = 0 ;
11061 int res1 = 0 ;
11062 PyObject *swig_obj[1] ;
11063
11064 if (!args) SWIG_fail;
11065 swig_obj[0] = args;
11066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11067 if (!SWIG_IsOK(res1)) {
11068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11069 }
11070 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11071 result = ((arg1)->m_x);
11072 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11073 return resultobj;
11074 fail:
11075 return NULL;
11076 }
11077
11078
11079 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11080 PyObject *resultobj = 0;
11081 wxRect2D *arg1 = (wxRect2D *) 0 ;
11082 wxDouble arg2 ;
11083 void *argp1 = 0 ;
11084 int res1 = 0 ;
11085 void *argp2 ;
11086 int res2 = 0 ;
11087 PyObject *swig_obj[2] ;
11088
11089 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11091 if (!SWIG_IsOK(res1)) {
11092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11093 }
11094 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11095 {
11096 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11097 if (!SWIG_IsOK(res2)) {
11098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11099 }
11100 if (!argp2) {
11101 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11102 } else {
11103 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11104 arg2 = *temp;
11105 if (SWIG_IsNewObj(res2)) delete temp;
11106 }
11107 }
11108 if (arg1) (arg1)->m_y = arg2;
11109
11110 resultobj = SWIG_Py_Void();
11111 return resultobj;
11112 fail:
11113 return NULL;
11114 }
11115
11116
11117 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11118 PyObject *resultobj = 0;
11119 wxRect2D *arg1 = (wxRect2D *) 0 ;
11120 wxDouble result;
11121 void *argp1 = 0 ;
11122 int res1 = 0 ;
11123 PyObject *swig_obj[1] ;
11124
11125 if (!args) SWIG_fail;
11126 swig_obj[0] = args;
11127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11128 if (!SWIG_IsOK(res1)) {
11129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11130 }
11131 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11132 result = ((arg1)->m_y);
11133 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11134 return resultobj;
11135 fail:
11136 return NULL;
11137 }
11138
11139
11140 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11141 PyObject *resultobj = 0;
11142 wxRect2D *arg1 = (wxRect2D *) 0 ;
11143 wxDouble arg2 ;
11144 void *argp1 = 0 ;
11145 int res1 = 0 ;
11146 void *argp2 ;
11147 int res2 = 0 ;
11148 PyObject *swig_obj[2] ;
11149
11150 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11152 if (!SWIG_IsOK(res1)) {
11153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11154 }
11155 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11156 {
11157 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11158 if (!SWIG_IsOK(res2)) {
11159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11160 }
11161 if (!argp2) {
11162 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11163 } else {
11164 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11165 arg2 = *temp;
11166 if (SWIG_IsNewObj(res2)) delete temp;
11167 }
11168 }
11169 if (arg1) (arg1)->m_width = arg2;
11170
11171 resultobj = SWIG_Py_Void();
11172 return resultobj;
11173 fail:
11174 return NULL;
11175 }
11176
11177
11178 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11179 PyObject *resultobj = 0;
11180 wxRect2D *arg1 = (wxRect2D *) 0 ;
11181 wxDouble result;
11182 void *argp1 = 0 ;
11183 int res1 = 0 ;
11184 PyObject *swig_obj[1] ;
11185
11186 if (!args) SWIG_fail;
11187 swig_obj[0] = args;
11188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11189 if (!SWIG_IsOK(res1)) {
11190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11191 }
11192 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11193 result = ((arg1)->m_width);
11194 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11195 return resultobj;
11196 fail:
11197 return NULL;
11198 }
11199
11200
11201 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11202 PyObject *resultobj = 0;
11203 wxRect2D *arg1 = (wxRect2D *) 0 ;
11204 wxDouble arg2 ;
11205 void *argp1 = 0 ;
11206 int res1 = 0 ;
11207 void *argp2 ;
11208 int res2 = 0 ;
11209 PyObject *swig_obj[2] ;
11210
11211 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11213 if (!SWIG_IsOK(res1)) {
11214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11215 }
11216 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11217 {
11218 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11219 if (!SWIG_IsOK(res2)) {
11220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11221 }
11222 if (!argp2) {
11223 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11224 } else {
11225 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11226 arg2 = *temp;
11227 if (SWIG_IsNewObj(res2)) delete temp;
11228 }
11229 }
11230 if (arg1) (arg1)->m_height = arg2;
11231
11232 resultobj = SWIG_Py_Void();
11233 return resultobj;
11234 fail:
11235 return NULL;
11236 }
11237
11238
11239 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11240 PyObject *resultobj = 0;
11241 wxRect2D *arg1 = (wxRect2D *) 0 ;
11242 wxDouble result;
11243 void *argp1 = 0 ;
11244 int res1 = 0 ;
11245 PyObject *swig_obj[1] ;
11246
11247 if (!args) SWIG_fail;
11248 swig_obj[0] = args;
11249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11250 if (!SWIG_IsOK(res1)) {
11251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11252 }
11253 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11254 result = ((arg1)->m_height);
11255 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11256 return resultobj;
11257 fail:
11258 return NULL;
11259 }
11260
11261
11262 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11263 PyObject *resultobj = 0;
11264 wxRect2D *arg1 = (wxRect2D *) 0 ;
11265 wxDouble arg2 = (wxDouble) 0 ;
11266 wxDouble arg3 = (wxDouble) 0 ;
11267 wxDouble arg4 = (wxDouble) 0 ;
11268 wxDouble arg5 = (wxDouble) 0 ;
11269 void *argp1 = 0 ;
11270 int res1 = 0 ;
11271 void *argp2 ;
11272 int res2 = 0 ;
11273 void *argp3 ;
11274 int res3 = 0 ;
11275 void *argp4 ;
11276 int res4 = 0 ;
11277 void *argp5 ;
11278 int res5 = 0 ;
11279 PyObject * obj0 = 0 ;
11280 PyObject * obj1 = 0 ;
11281 PyObject * obj2 = 0 ;
11282 PyObject * obj3 = 0 ;
11283 PyObject * obj4 = 0 ;
11284 char * kwnames[] = {
11285 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11286 };
11287
11288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11290 if (!SWIG_IsOK(res1)) {
11291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11292 }
11293 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11294 if (obj1) {
11295 {
11296 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11297 if (!SWIG_IsOK(res2)) {
11298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11299 }
11300 if (!argp2) {
11301 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11302 } else {
11303 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11304 arg2 = *temp;
11305 if (SWIG_IsNewObj(res2)) delete temp;
11306 }
11307 }
11308 }
11309 if (obj2) {
11310 {
11311 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11312 if (!SWIG_IsOK(res3)) {
11313 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11314 }
11315 if (!argp3) {
11316 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11317 } else {
11318 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11319 arg3 = *temp;
11320 if (SWIG_IsNewObj(res3)) delete temp;
11321 }
11322 }
11323 }
11324 if (obj3) {
11325 {
11326 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11327 if (!SWIG_IsOK(res4)) {
11328 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11329 }
11330 if (!argp4) {
11331 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11332 } else {
11333 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11334 arg4 = *temp;
11335 if (SWIG_IsNewObj(res4)) delete temp;
11336 }
11337 }
11338 }
11339 if (obj4) {
11340 {
11341 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11342 if (!SWIG_IsOK(res5)) {
11343 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11344 }
11345 if (!argp5) {
11346 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11347 } else {
11348 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11349 arg5 = *temp;
11350 if (SWIG_IsNewObj(res5)) delete temp;
11351 }
11352 }
11353 }
11354 {
11355 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11356 if (PyErr_Occurred()) SWIG_fail;
11357 }
11358 resultobj = SWIG_Py_Void();
11359 return resultobj;
11360 fail:
11361 return NULL;
11362 }
11363
11364
11365 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11366 PyObject *resultobj = 0;
11367 wxRect2D *arg1 = (wxRect2D *) 0 ;
11368 PyObject *result = 0 ;
11369 void *argp1 = 0 ;
11370 int res1 = 0 ;
11371 PyObject *swig_obj[1] ;
11372
11373 if (!args) SWIG_fail;
11374 swig_obj[0] = args;
11375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11376 if (!SWIG_IsOK(res1)) {
11377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11378 }
11379 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11380 {
11381 result = (PyObject *)wxRect2D_Get(arg1);
11382 if (PyErr_Occurred()) SWIG_fail;
11383 }
11384 resultobj = result;
11385 return resultobj;
11386 fail:
11387 return NULL;
11388 }
11389
11390
11391 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11392 PyObject *obj;
11393 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11394 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11395 return SWIG_Py_Void();
11396 }
11397
11398 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11399 return SWIG_Python_InitShadowInstance(args);
11400 }
11401
11402 SWIGINTERN int DefaultPosition_set(PyObject *) {
11403 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11404 return 1;
11405 }
11406
11407
11408 SWIGINTERN PyObject *DefaultPosition_get(void) {
11409 PyObject *pyobj = 0;
11410
11411 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11412 return pyobj;
11413 }
11414
11415
11416 SWIGINTERN int DefaultSize_set(PyObject *) {
11417 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11418 return 1;
11419 }
11420
11421
11422 SWIGINTERN PyObject *DefaultSize_get(void) {
11423 PyObject *pyobj = 0;
11424
11425 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11426 return pyobj;
11427 }
11428
11429
11430 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11431 PyObject *resultobj = 0;
11432 PyObject *arg1 = (PyObject *) 0 ;
11433 wxPyInputStream *result = 0 ;
11434 PyObject * obj0 = 0 ;
11435 char * kwnames[] = {
11436 (char *) "p", NULL
11437 };
11438
11439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11440 arg1 = obj0;
11441 {
11442 PyThreadState* __tstate = wxPyBeginAllowThreads();
11443 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11444 wxPyEndAllowThreads(__tstate);
11445 if (PyErr_Occurred()) SWIG_fail;
11446 }
11447 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11448 return resultobj;
11449 fail:
11450 return NULL;
11451 }
11452
11453
11454 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11455 PyObject *resultobj = 0;
11456 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11457 void *argp1 = 0 ;
11458 int res1 = 0 ;
11459 PyObject *swig_obj[1] ;
11460
11461 if (!args) SWIG_fail;
11462 swig_obj[0] = args;
11463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
11464 if (!SWIG_IsOK(res1)) {
11465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11466 }
11467 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11468 {
11469 PyThreadState* __tstate = wxPyBeginAllowThreads();
11470 delete arg1;
11471
11472 wxPyEndAllowThreads(__tstate);
11473 if (PyErr_Occurred()) SWIG_fail;
11474 }
11475 resultobj = SWIG_Py_Void();
11476 return resultobj;
11477 fail:
11478 return NULL;
11479 }
11480
11481
11482 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11483 PyObject *resultobj = 0;
11484 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11485 void *argp1 = 0 ;
11486 int res1 = 0 ;
11487 PyObject *swig_obj[1] ;
11488
11489 if (!args) SWIG_fail;
11490 swig_obj[0] = args;
11491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11492 if (!SWIG_IsOK(res1)) {
11493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11494 }
11495 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11496 {
11497 PyThreadState* __tstate = wxPyBeginAllowThreads();
11498 (arg1)->close();
11499 wxPyEndAllowThreads(__tstate);
11500 if (PyErr_Occurred()) SWIG_fail;
11501 }
11502 resultobj = SWIG_Py_Void();
11503 return resultobj;
11504 fail:
11505 return NULL;
11506 }
11507
11508
11509 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11510 PyObject *resultobj = 0;
11511 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11512 void *argp1 = 0 ;
11513 int res1 = 0 ;
11514 PyObject *swig_obj[1] ;
11515
11516 if (!args) SWIG_fail;
11517 swig_obj[0] = args;
11518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11519 if (!SWIG_IsOK(res1)) {
11520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11521 }
11522 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11523 {
11524 PyThreadState* __tstate = wxPyBeginAllowThreads();
11525 (arg1)->flush();
11526 wxPyEndAllowThreads(__tstate);
11527 if (PyErr_Occurred()) SWIG_fail;
11528 }
11529 resultobj = SWIG_Py_Void();
11530 return resultobj;
11531 fail:
11532 return NULL;
11533 }
11534
11535
11536 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11537 PyObject *resultobj = 0;
11538 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11539 bool result;
11540 void *argp1 = 0 ;
11541 int res1 = 0 ;
11542 PyObject *swig_obj[1] ;
11543
11544 if (!args) SWIG_fail;
11545 swig_obj[0] = args;
11546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11547 if (!SWIG_IsOK(res1)) {
11548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11549 }
11550 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11551 {
11552 PyThreadState* __tstate = wxPyBeginAllowThreads();
11553 result = (bool)(arg1)->eof();
11554 wxPyEndAllowThreads(__tstate);
11555 if (PyErr_Occurred()) SWIG_fail;
11556 }
11557 {
11558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11559 }
11560 return resultobj;
11561 fail:
11562 return NULL;
11563 }
11564
11565
11566 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11567 PyObject *resultobj = 0;
11568 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11569 int arg2 = (int) -1 ;
11570 PyObject *result = 0 ;
11571 void *argp1 = 0 ;
11572 int res1 = 0 ;
11573 int val2 ;
11574 int ecode2 = 0 ;
11575 PyObject * obj0 = 0 ;
11576 PyObject * obj1 = 0 ;
11577 char * kwnames[] = {
11578 (char *) "self",(char *) "size", NULL
11579 };
11580
11581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11583 if (!SWIG_IsOK(res1)) {
11584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11585 }
11586 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11587 if (obj1) {
11588 ecode2 = SWIG_AsVal_int(obj1, &val2);
11589 if (!SWIG_IsOK(ecode2)) {
11590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11591 }
11592 arg2 = static_cast< int >(val2);
11593 }
11594 {
11595 PyThreadState* __tstate = wxPyBeginAllowThreads();
11596 result = (PyObject *)(arg1)->read(arg2);
11597 wxPyEndAllowThreads(__tstate);
11598 if (PyErr_Occurred()) SWIG_fail;
11599 }
11600 resultobj = result;
11601 return resultobj;
11602 fail:
11603 return NULL;
11604 }
11605
11606
11607 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11608 PyObject *resultobj = 0;
11609 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11610 int arg2 = (int) -1 ;
11611 PyObject *result = 0 ;
11612 void *argp1 = 0 ;
11613 int res1 = 0 ;
11614 int val2 ;
11615 int ecode2 = 0 ;
11616 PyObject * obj0 = 0 ;
11617 PyObject * obj1 = 0 ;
11618 char * kwnames[] = {
11619 (char *) "self",(char *) "size", NULL
11620 };
11621
11622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11624 if (!SWIG_IsOK(res1)) {
11625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11626 }
11627 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11628 if (obj1) {
11629 ecode2 = SWIG_AsVal_int(obj1, &val2);
11630 if (!SWIG_IsOK(ecode2)) {
11631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11632 }
11633 arg2 = static_cast< int >(val2);
11634 }
11635 {
11636 PyThreadState* __tstate = wxPyBeginAllowThreads();
11637 result = (PyObject *)(arg1)->readline(arg2);
11638 wxPyEndAllowThreads(__tstate);
11639 if (PyErr_Occurred()) SWIG_fail;
11640 }
11641 resultobj = result;
11642 return resultobj;
11643 fail:
11644 return NULL;
11645 }
11646
11647
11648 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11649 PyObject *resultobj = 0;
11650 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11651 int arg2 = (int) -1 ;
11652 PyObject *result = 0 ;
11653 void *argp1 = 0 ;
11654 int res1 = 0 ;
11655 int val2 ;
11656 int ecode2 = 0 ;
11657 PyObject * obj0 = 0 ;
11658 PyObject * obj1 = 0 ;
11659 char * kwnames[] = {
11660 (char *) "self",(char *) "sizehint", NULL
11661 };
11662
11663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11665 if (!SWIG_IsOK(res1)) {
11666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11667 }
11668 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11669 if (obj1) {
11670 ecode2 = SWIG_AsVal_int(obj1, &val2);
11671 if (!SWIG_IsOK(ecode2)) {
11672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11673 }
11674 arg2 = static_cast< int >(val2);
11675 }
11676 {
11677 PyThreadState* __tstate = wxPyBeginAllowThreads();
11678 result = (PyObject *)(arg1)->readlines(arg2);
11679 wxPyEndAllowThreads(__tstate);
11680 if (PyErr_Occurred()) SWIG_fail;
11681 }
11682 resultobj = result;
11683 return resultobj;
11684 fail:
11685 return NULL;
11686 }
11687
11688
11689 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11690 PyObject *resultobj = 0;
11691 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11692 int arg2 ;
11693 int arg3 = (int) 0 ;
11694 void *argp1 = 0 ;
11695 int res1 = 0 ;
11696 int val2 ;
11697 int ecode2 = 0 ;
11698 int val3 ;
11699 int ecode3 = 0 ;
11700 PyObject * obj0 = 0 ;
11701 PyObject * obj1 = 0 ;
11702 PyObject * obj2 = 0 ;
11703 char * kwnames[] = {
11704 (char *) "self",(char *) "offset",(char *) "whence", NULL
11705 };
11706
11707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11709 if (!SWIG_IsOK(res1)) {
11710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11711 }
11712 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11713 ecode2 = SWIG_AsVal_int(obj1, &val2);
11714 if (!SWIG_IsOK(ecode2)) {
11715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11716 }
11717 arg2 = static_cast< int >(val2);
11718 if (obj2) {
11719 ecode3 = SWIG_AsVal_int(obj2, &val3);
11720 if (!SWIG_IsOK(ecode3)) {
11721 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11722 }
11723 arg3 = static_cast< int >(val3);
11724 }
11725 {
11726 PyThreadState* __tstate = wxPyBeginAllowThreads();
11727 (arg1)->seek(arg2,arg3);
11728 wxPyEndAllowThreads(__tstate);
11729 if (PyErr_Occurred()) SWIG_fail;
11730 }
11731 resultobj = SWIG_Py_Void();
11732 return resultobj;
11733 fail:
11734 return NULL;
11735 }
11736
11737
11738 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11739 PyObject *resultobj = 0;
11740 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11741 int result;
11742 void *argp1 = 0 ;
11743 int res1 = 0 ;
11744 PyObject *swig_obj[1] ;
11745
11746 if (!args) SWIG_fail;
11747 swig_obj[0] = args;
11748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11749 if (!SWIG_IsOK(res1)) {
11750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11751 }
11752 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11753 {
11754 PyThreadState* __tstate = wxPyBeginAllowThreads();
11755 result = (int)(arg1)->tell();
11756 wxPyEndAllowThreads(__tstate);
11757 if (PyErr_Occurred()) SWIG_fail;
11758 }
11759 resultobj = SWIG_From_int(static_cast< int >(result));
11760 return resultobj;
11761 fail:
11762 return NULL;
11763 }
11764
11765
11766 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11767 PyObject *resultobj = 0;
11768 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11769 char result;
11770 void *argp1 = 0 ;
11771 int res1 = 0 ;
11772 PyObject *swig_obj[1] ;
11773
11774 if (!args) SWIG_fail;
11775 swig_obj[0] = args;
11776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11777 if (!SWIG_IsOK(res1)) {
11778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11779 }
11780 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11781 {
11782 PyThreadState* __tstate = wxPyBeginAllowThreads();
11783 result = (char)(arg1)->Peek();
11784 wxPyEndAllowThreads(__tstate);
11785 if (PyErr_Occurred()) SWIG_fail;
11786 }
11787 resultobj = SWIG_From_char(static_cast< char >(result));
11788 return resultobj;
11789 fail:
11790 return NULL;
11791 }
11792
11793
11794 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11795 PyObject *resultobj = 0;
11796 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11797 char result;
11798 void *argp1 = 0 ;
11799 int res1 = 0 ;
11800 PyObject *swig_obj[1] ;
11801
11802 if (!args) SWIG_fail;
11803 swig_obj[0] = args;
11804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11805 if (!SWIG_IsOK(res1)) {
11806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11807 }
11808 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11809 {
11810 PyThreadState* __tstate = wxPyBeginAllowThreads();
11811 result = (char)(arg1)->GetC();
11812 wxPyEndAllowThreads(__tstate);
11813 if (PyErr_Occurred()) SWIG_fail;
11814 }
11815 resultobj = SWIG_From_char(static_cast< char >(result));
11816 return resultobj;
11817 fail:
11818 return NULL;
11819 }
11820
11821
11822 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11823 PyObject *resultobj = 0;
11824 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11825 size_t result;
11826 void *argp1 = 0 ;
11827 int res1 = 0 ;
11828 PyObject *swig_obj[1] ;
11829
11830 if (!args) SWIG_fail;
11831 swig_obj[0] = args;
11832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11833 if (!SWIG_IsOK(res1)) {
11834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11835 }
11836 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11837 {
11838 PyThreadState* __tstate = wxPyBeginAllowThreads();
11839 result = (size_t)(arg1)->LastRead();
11840 wxPyEndAllowThreads(__tstate);
11841 if (PyErr_Occurred()) SWIG_fail;
11842 }
11843 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11844 return resultobj;
11845 fail:
11846 return NULL;
11847 }
11848
11849
11850 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11851 PyObject *resultobj = 0;
11852 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11853 bool result;
11854 void *argp1 = 0 ;
11855 int res1 = 0 ;
11856 PyObject *swig_obj[1] ;
11857
11858 if (!args) SWIG_fail;
11859 swig_obj[0] = args;
11860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11861 if (!SWIG_IsOK(res1)) {
11862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11863 }
11864 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11865 {
11866 PyThreadState* __tstate = wxPyBeginAllowThreads();
11867 result = (bool)(arg1)->CanRead();
11868 wxPyEndAllowThreads(__tstate);
11869 if (PyErr_Occurred()) SWIG_fail;
11870 }
11871 {
11872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11873 }
11874 return resultobj;
11875 fail:
11876 return NULL;
11877 }
11878
11879
11880 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11881 PyObject *resultobj = 0;
11882 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11883 bool result;
11884 void *argp1 = 0 ;
11885 int res1 = 0 ;
11886 PyObject *swig_obj[1] ;
11887
11888 if (!args) SWIG_fail;
11889 swig_obj[0] = args;
11890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11891 if (!SWIG_IsOK(res1)) {
11892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11893 }
11894 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11895 {
11896 PyThreadState* __tstate = wxPyBeginAllowThreads();
11897 result = (bool)(arg1)->Eof();
11898 wxPyEndAllowThreads(__tstate);
11899 if (PyErr_Occurred()) SWIG_fail;
11900 }
11901 {
11902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11903 }
11904 return resultobj;
11905 fail:
11906 return NULL;
11907 }
11908
11909
11910 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11911 PyObject *resultobj = 0;
11912 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11913 char arg2 ;
11914 bool result;
11915 void *argp1 = 0 ;
11916 int res1 = 0 ;
11917 char val2 ;
11918 int ecode2 = 0 ;
11919 PyObject * obj0 = 0 ;
11920 PyObject * obj1 = 0 ;
11921 char * kwnames[] = {
11922 (char *) "self",(char *) "c", NULL
11923 };
11924
11925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11927 if (!SWIG_IsOK(res1)) {
11928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11929 }
11930 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11931 ecode2 = SWIG_AsVal_char(obj1, &val2);
11932 if (!SWIG_IsOK(ecode2)) {
11933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
11934 }
11935 arg2 = static_cast< char >(val2);
11936 {
11937 PyThreadState* __tstate = wxPyBeginAllowThreads();
11938 result = (bool)(arg1)->Ungetch(arg2);
11939 wxPyEndAllowThreads(__tstate);
11940 if (PyErr_Occurred()) SWIG_fail;
11941 }
11942 {
11943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11944 }
11945 return resultobj;
11946 fail:
11947 return NULL;
11948 }
11949
11950
11951 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11952 PyObject *resultobj = 0;
11953 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11954 long arg2 ;
11955 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
11956 long result;
11957 void *argp1 = 0 ;
11958 int res1 = 0 ;
11959 long val2 ;
11960 int ecode2 = 0 ;
11961 int val3 ;
11962 int ecode3 = 0 ;
11963 PyObject * obj0 = 0 ;
11964 PyObject * obj1 = 0 ;
11965 PyObject * obj2 = 0 ;
11966 char * kwnames[] = {
11967 (char *) "self",(char *) "pos",(char *) "mode", NULL
11968 };
11969
11970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11972 if (!SWIG_IsOK(res1)) {
11973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11974 }
11975 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11976 ecode2 = SWIG_AsVal_long(obj1, &val2);
11977 if (!SWIG_IsOK(ecode2)) {
11978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
11979 }
11980 arg2 = static_cast< long >(val2);
11981 if (obj2) {
11982 ecode3 = SWIG_AsVal_int(obj2, &val3);
11983 if (!SWIG_IsOK(ecode3)) {
11984 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
11985 }
11986 arg3 = static_cast< wxSeekMode >(val3);
11987 }
11988 {
11989 PyThreadState* __tstate = wxPyBeginAllowThreads();
11990 result = (long)(arg1)->SeekI(arg2,arg3);
11991 wxPyEndAllowThreads(__tstate);
11992 if (PyErr_Occurred()) SWIG_fail;
11993 }
11994 resultobj = SWIG_From_long(static_cast< long >(result));
11995 return resultobj;
11996 fail:
11997 return NULL;
11998 }
11999
12000
12001 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12002 PyObject *resultobj = 0;
12003 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12004 long result;
12005 void *argp1 = 0 ;
12006 int res1 = 0 ;
12007 PyObject *swig_obj[1] ;
12008
12009 if (!args) SWIG_fail;
12010 swig_obj[0] = args;
12011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12012 if (!SWIG_IsOK(res1)) {
12013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12014 }
12015 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12016 {
12017 PyThreadState* __tstate = wxPyBeginAllowThreads();
12018 result = (long)(arg1)->TellI();
12019 wxPyEndAllowThreads(__tstate);
12020 if (PyErr_Occurred()) SWIG_fail;
12021 }
12022 resultobj = SWIG_From_long(static_cast< long >(result));
12023 return resultobj;
12024 fail:
12025 return NULL;
12026 }
12027
12028
12029 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12030 PyObject *obj;
12031 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12032 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12033 return SWIG_Py_Void();
12034 }
12035
12036 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12037 return SWIG_Python_InitShadowInstance(args);
12038 }
12039
12040 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12041 PyObject *resultobj = 0;
12042 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12043 PyObject *arg2 = (PyObject *) 0 ;
12044 void *argp1 = 0 ;
12045 int res1 = 0 ;
12046 PyObject * obj0 = 0 ;
12047 PyObject * obj1 = 0 ;
12048 char * kwnames[] = {
12049 (char *) "self",(char *) "obj", NULL
12050 };
12051
12052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12054 if (!SWIG_IsOK(res1)) {
12055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12056 }
12057 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12058 arg2 = obj1;
12059 {
12060 PyThreadState* __tstate = wxPyBeginAllowThreads();
12061 wxOutputStream_write(arg1,arg2);
12062 wxPyEndAllowThreads(__tstate);
12063 if (PyErr_Occurred()) SWIG_fail;
12064 }
12065 resultobj = SWIG_Py_Void();
12066 return resultobj;
12067 fail:
12068 return NULL;
12069 }
12070
12071
12072 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12073 PyObject *resultobj = 0;
12074 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12075 size_t result;
12076 void *argp1 = 0 ;
12077 int res1 = 0 ;
12078 PyObject *swig_obj[1] ;
12079
12080 if (!args) SWIG_fail;
12081 swig_obj[0] = args;
12082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12083 if (!SWIG_IsOK(res1)) {
12084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12085 }
12086 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12087 {
12088 PyThreadState* __tstate = wxPyBeginAllowThreads();
12089 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12090 wxPyEndAllowThreads(__tstate);
12091 if (PyErr_Occurred()) SWIG_fail;
12092 }
12093 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12094 return resultobj;
12095 fail:
12096 return NULL;
12097 }
12098
12099
12100 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12101 PyObject *obj;
12102 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12103 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12104 return SWIG_Py_Void();
12105 }
12106
12107 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12108 PyObject *resultobj = 0;
12109 wxInputStream *arg1 = (wxInputStream *) 0 ;
12110 wxString *arg2 = 0 ;
12111 wxString *arg3 = 0 ;
12112 wxString *arg4 = 0 ;
12113 wxDateTime arg5 ;
12114 wxFSFile *result = 0 ;
12115 wxPyInputStream *temp1 ;
12116 bool temp2 = false ;
12117 bool temp3 = false ;
12118 bool temp4 = false ;
12119 void *argp5 ;
12120 int res5 = 0 ;
12121 PyObject * obj0 = 0 ;
12122 PyObject * obj1 = 0 ;
12123 PyObject * obj2 = 0 ;
12124 PyObject * obj3 = 0 ;
12125 PyObject * obj4 = 0 ;
12126 char * kwnames[] = {
12127 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12128 };
12129
12130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12131 {
12132 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12133 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12134 } else {
12135 PyErr_Clear(); // clear the failure of the wxPyConvert above
12136 arg1 = wxPyCBInputStream_create(obj0, true);
12137 if (arg1 == NULL) {
12138 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12139 SWIG_fail;
12140 }
12141 }
12142 }
12143 {
12144 arg2 = wxString_in_helper(obj1);
12145 if (arg2 == NULL) SWIG_fail;
12146 temp2 = true;
12147 }
12148 {
12149 arg3 = wxString_in_helper(obj2);
12150 if (arg3 == NULL) SWIG_fail;
12151 temp3 = true;
12152 }
12153 {
12154 arg4 = wxString_in_helper(obj3);
12155 if (arg4 == NULL) SWIG_fail;
12156 temp4 = true;
12157 }
12158 {
12159 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12160 if (!SWIG_IsOK(res5)) {
12161 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12162 }
12163 if (!argp5) {
12164 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12165 } else {
12166 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12167 arg5 = *temp;
12168 if (SWIG_IsNewObj(res5)) delete temp;
12169 }
12170 }
12171 {
12172 PyThreadState* __tstate = wxPyBeginAllowThreads();
12173 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12174 wxPyEndAllowThreads(__tstate);
12175 if (PyErr_Occurred()) SWIG_fail;
12176 }
12177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12178 {
12179 if (temp2)
12180 delete arg2;
12181 }
12182 {
12183 if (temp3)
12184 delete arg3;
12185 }
12186 {
12187 if (temp4)
12188 delete arg4;
12189 }
12190 return resultobj;
12191 fail:
12192 {
12193 if (temp2)
12194 delete arg2;
12195 }
12196 {
12197 if (temp3)
12198 delete arg3;
12199 }
12200 {
12201 if (temp4)
12202 delete arg4;
12203 }
12204 return NULL;
12205 }
12206
12207
12208 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12209 PyObject *resultobj = 0;
12210 wxFSFile *arg1 = (wxFSFile *) 0 ;
12211 void *argp1 = 0 ;
12212 int res1 = 0 ;
12213 PyObject *swig_obj[1] ;
12214
12215 if (!args) SWIG_fail;
12216 swig_obj[0] = args;
12217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12218 if (!SWIG_IsOK(res1)) {
12219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12220 }
12221 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12222 {
12223 PyThreadState* __tstate = wxPyBeginAllowThreads();
12224 delete arg1;
12225
12226 wxPyEndAllowThreads(__tstate);
12227 if (PyErr_Occurred()) SWIG_fail;
12228 }
12229 resultobj = SWIG_Py_Void();
12230 return resultobj;
12231 fail:
12232 return NULL;
12233 }
12234
12235
12236 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12237 PyObject *resultobj = 0;
12238 wxFSFile *arg1 = (wxFSFile *) 0 ;
12239 wxInputStream *result = 0 ;
12240 void *argp1 = 0 ;
12241 int res1 = 0 ;
12242 PyObject *swig_obj[1] ;
12243
12244 if (!args) SWIG_fail;
12245 swig_obj[0] = args;
12246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12247 if (!SWIG_IsOK(res1)) {
12248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12249 }
12250 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12251 {
12252 PyThreadState* __tstate = wxPyBeginAllowThreads();
12253 result = (wxInputStream *)(arg1)->GetStream();
12254 wxPyEndAllowThreads(__tstate);
12255 if (PyErr_Occurred()) SWIG_fail;
12256 }
12257 {
12258 wxPyInputStream * _ptr = NULL;
12259
12260 if (result) {
12261 _ptr = new wxPyInputStream(result);
12262 }
12263 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12264 }
12265 return resultobj;
12266 fail:
12267 return NULL;
12268 }
12269
12270
12271 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12272 PyObject *resultobj = 0;
12273 wxFSFile *arg1 = (wxFSFile *) 0 ;
12274 void *argp1 = 0 ;
12275 int res1 = 0 ;
12276 PyObject *swig_obj[1] ;
12277
12278 if (!args) SWIG_fail;
12279 swig_obj[0] = args;
12280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12281 if (!SWIG_IsOK(res1)) {
12282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12283 }
12284 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12285 {
12286 PyThreadState* __tstate = wxPyBeginAllowThreads();
12287 (arg1)->DetachStream();
12288 wxPyEndAllowThreads(__tstate);
12289 if (PyErr_Occurred()) SWIG_fail;
12290 }
12291 resultobj = SWIG_Py_Void();
12292 return resultobj;
12293 fail:
12294 return NULL;
12295 }
12296
12297
12298 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12299 PyObject *resultobj = 0;
12300 wxFSFile *arg1 = (wxFSFile *) 0 ;
12301 wxString *result = 0 ;
12302 void *argp1 = 0 ;
12303 int res1 = 0 ;
12304 PyObject *swig_obj[1] ;
12305
12306 if (!args) SWIG_fail;
12307 swig_obj[0] = args;
12308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12309 if (!SWIG_IsOK(res1)) {
12310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12311 }
12312 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12313 {
12314 PyThreadState* __tstate = wxPyBeginAllowThreads();
12315 {
12316 wxString const &_result_ref = (arg1)->GetMimeType();
12317 result = (wxString *) &_result_ref;
12318 }
12319 wxPyEndAllowThreads(__tstate);
12320 if (PyErr_Occurred()) SWIG_fail;
12321 }
12322 {
12323 #if wxUSE_UNICODE
12324 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12325 #else
12326 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12327 #endif
12328 }
12329 return resultobj;
12330 fail:
12331 return NULL;
12332 }
12333
12334
12335 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12336 PyObject *resultobj = 0;
12337 wxFSFile *arg1 = (wxFSFile *) 0 ;
12338 wxString *result = 0 ;
12339 void *argp1 = 0 ;
12340 int res1 = 0 ;
12341 PyObject *swig_obj[1] ;
12342
12343 if (!args) SWIG_fail;
12344 swig_obj[0] = args;
12345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12346 if (!SWIG_IsOK(res1)) {
12347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12348 }
12349 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12350 {
12351 PyThreadState* __tstate = wxPyBeginAllowThreads();
12352 {
12353 wxString const &_result_ref = (arg1)->GetLocation();
12354 result = (wxString *) &_result_ref;
12355 }
12356 wxPyEndAllowThreads(__tstate);
12357 if (PyErr_Occurred()) SWIG_fail;
12358 }
12359 {
12360 #if wxUSE_UNICODE
12361 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12362 #else
12363 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12364 #endif
12365 }
12366 return resultobj;
12367 fail:
12368 return NULL;
12369 }
12370
12371
12372 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12373 PyObject *resultobj = 0;
12374 wxFSFile *arg1 = (wxFSFile *) 0 ;
12375 wxString *result = 0 ;
12376 void *argp1 = 0 ;
12377 int res1 = 0 ;
12378 PyObject *swig_obj[1] ;
12379
12380 if (!args) SWIG_fail;
12381 swig_obj[0] = args;
12382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12383 if (!SWIG_IsOK(res1)) {
12384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12385 }
12386 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12387 {
12388 PyThreadState* __tstate = wxPyBeginAllowThreads();
12389 {
12390 wxString const &_result_ref = (arg1)->GetAnchor();
12391 result = (wxString *) &_result_ref;
12392 }
12393 wxPyEndAllowThreads(__tstate);
12394 if (PyErr_Occurred()) SWIG_fail;
12395 }
12396 {
12397 #if wxUSE_UNICODE
12398 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12399 #else
12400 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12401 #endif
12402 }
12403 return resultobj;
12404 fail:
12405 return NULL;
12406 }
12407
12408
12409 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12410 PyObject *resultobj = 0;
12411 wxFSFile *arg1 = (wxFSFile *) 0 ;
12412 wxDateTime result;
12413 void *argp1 = 0 ;
12414 int res1 = 0 ;
12415 PyObject *swig_obj[1] ;
12416
12417 if (!args) SWIG_fail;
12418 swig_obj[0] = args;
12419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12420 if (!SWIG_IsOK(res1)) {
12421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12422 }
12423 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12424 {
12425 PyThreadState* __tstate = wxPyBeginAllowThreads();
12426 result = (arg1)->GetModificationTime();
12427 wxPyEndAllowThreads(__tstate);
12428 if (PyErr_Occurred()) SWIG_fail;
12429 }
12430 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12431 return resultobj;
12432 fail:
12433 return NULL;
12434 }
12435
12436
12437 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12438 PyObject *obj;
12439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12440 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12441 return SWIG_Py_Void();
12442 }
12443
12444 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12445 return SWIG_Python_InitShadowInstance(args);
12446 }
12447
12448 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12449 PyObject *resultobj = 0;
12450 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12451 void *argp1 = 0 ;
12452 int res1 = 0 ;
12453 PyObject *swig_obj[1] ;
12454
12455 if (!args) SWIG_fail;
12456 swig_obj[0] = args;
12457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12458 if (!SWIG_IsOK(res1)) {
12459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12460 }
12461 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12462 {
12463 PyThreadState* __tstate = wxPyBeginAllowThreads();
12464 delete arg1;
12465
12466 wxPyEndAllowThreads(__tstate);
12467 if (PyErr_Occurred()) SWIG_fail;
12468 }
12469 resultobj = SWIG_Py_Void();
12470 return resultobj;
12471 fail:
12472 return NULL;
12473 }
12474
12475
12476 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12477 PyObject *obj;
12478 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12479 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12480 return SWIG_Py_Void();
12481 }
12482
12483 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12484 PyObject *resultobj = 0;
12485 wxPyFileSystemHandler *result = 0 ;
12486
12487 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12488 {
12489 PyThreadState* __tstate = wxPyBeginAllowThreads();
12490 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12491 wxPyEndAllowThreads(__tstate);
12492 if (PyErr_Occurred()) SWIG_fail;
12493 }
12494 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12495 return resultobj;
12496 fail:
12497 return NULL;
12498 }
12499
12500
12501 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12502 PyObject *resultobj = 0;
12503 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12504 PyObject *arg2 = (PyObject *) 0 ;
12505 PyObject *arg3 = (PyObject *) 0 ;
12506 void *argp1 = 0 ;
12507 int res1 = 0 ;
12508 PyObject * obj0 = 0 ;
12509 PyObject * obj1 = 0 ;
12510 PyObject * obj2 = 0 ;
12511 char * kwnames[] = {
12512 (char *) "self",(char *) "self",(char *) "_class", NULL
12513 };
12514
12515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12517 if (!SWIG_IsOK(res1)) {
12518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12519 }
12520 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12521 arg2 = obj1;
12522 arg3 = obj2;
12523 {
12524 PyThreadState* __tstate = wxPyBeginAllowThreads();
12525 (arg1)->_setCallbackInfo(arg2,arg3);
12526 wxPyEndAllowThreads(__tstate);
12527 if (PyErr_Occurred()) SWIG_fail;
12528 }
12529 resultobj = SWIG_Py_Void();
12530 return resultobj;
12531 fail:
12532 return NULL;
12533 }
12534
12535
12536 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12537 PyObject *resultobj = 0;
12538 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12539 wxString *arg2 = 0 ;
12540 bool result;
12541 void *argp1 = 0 ;
12542 int res1 = 0 ;
12543 bool temp2 = false ;
12544 PyObject * obj0 = 0 ;
12545 PyObject * obj1 = 0 ;
12546 char * kwnames[] = {
12547 (char *) "self",(char *) "location", NULL
12548 };
12549
12550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12552 if (!SWIG_IsOK(res1)) {
12553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12554 }
12555 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12556 {
12557 arg2 = wxString_in_helper(obj1);
12558 if (arg2 == NULL) SWIG_fail;
12559 temp2 = true;
12560 }
12561 {
12562 PyThreadState* __tstate = wxPyBeginAllowThreads();
12563 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12564 wxPyEndAllowThreads(__tstate);
12565 if (PyErr_Occurred()) SWIG_fail;
12566 }
12567 {
12568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12569 }
12570 {
12571 if (temp2)
12572 delete arg2;
12573 }
12574 return resultobj;
12575 fail:
12576 {
12577 if (temp2)
12578 delete arg2;
12579 }
12580 return NULL;
12581 }
12582
12583
12584 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12585 PyObject *resultobj = 0;
12586 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12587 wxFileSystem *arg2 = 0 ;
12588 wxString *arg3 = 0 ;
12589 wxFSFile *result = 0 ;
12590 void *argp1 = 0 ;
12591 int res1 = 0 ;
12592 void *argp2 = 0 ;
12593 int res2 = 0 ;
12594 bool temp3 = false ;
12595 PyObject * obj0 = 0 ;
12596 PyObject * obj1 = 0 ;
12597 PyObject * obj2 = 0 ;
12598 char * kwnames[] = {
12599 (char *) "self",(char *) "fs",(char *) "location", NULL
12600 };
12601
12602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12604 if (!SWIG_IsOK(res1)) {
12605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12606 }
12607 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12608 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12609 if (!SWIG_IsOK(res2)) {
12610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12611 }
12612 if (!argp2) {
12613 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12614 }
12615 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12616 {
12617 arg3 = wxString_in_helper(obj2);
12618 if (arg3 == NULL) SWIG_fail;
12619 temp3 = true;
12620 }
12621 {
12622 PyThreadState* __tstate = wxPyBeginAllowThreads();
12623 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12624 wxPyEndAllowThreads(__tstate);
12625 if (PyErr_Occurred()) SWIG_fail;
12626 }
12627 {
12628 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
12629 }
12630 {
12631 if (temp3)
12632 delete arg3;
12633 }
12634 return resultobj;
12635 fail:
12636 {
12637 if (temp3)
12638 delete arg3;
12639 }
12640 return NULL;
12641 }
12642
12643
12644 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12645 PyObject *resultobj = 0;
12646 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12647 wxString *arg2 = 0 ;
12648 int arg3 = (int) 0 ;
12649 wxString result;
12650 void *argp1 = 0 ;
12651 int res1 = 0 ;
12652 bool temp2 = false ;
12653 int val3 ;
12654 int ecode3 = 0 ;
12655 PyObject * obj0 = 0 ;
12656 PyObject * obj1 = 0 ;
12657 PyObject * obj2 = 0 ;
12658 char * kwnames[] = {
12659 (char *) "self",(char *) "spec",(char *) "flags", NULL
12660 };
12661
12662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12664 if (!SWIG_IsOK(res1)) {
12665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12666 }
12667 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12668 {
12669 arg2 = wxString_in_helper(obj1);
12670 if (arg2 == NULL) SWIG_fail;
12671 temp2 = true;
12672 }
12673 if (obj2) {
12674 ecode3 = SWIG_AsVal_int(obj2, &val3);
12675 if (!SWIG_IsOK(ecode3)) {
12676 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12677 }
12678 arg3 = static_cast< int >(val3);
12679 }
12680 {
12681 PyThreadState* __tstate = wxPyBeginAllowThreads();
12682 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12683 wxPyEndAllowThreads(__tstate);
12684 if (PyErr_Occurred()) SWIG_fail;
12685 }
12686 {
12687 #if wxUSE_UNICODE
12688 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12689 #else
12690 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12691 #endif
12692 }
12693 {
12694 if (temp2)
12695 delete arg2;
12696 }
12697 return resultobj;
12698 fail:
12699 {
12700 if (temp2)
12701 delete arg2;
12702 }
12703 return NULL;
12704 }
12705
12706
12707 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12708 PyObject *resultobj = 0;
12709 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12710 wxString result;
12711 void *argp1 = 0 ;
12712 int res1 = 0 ;
12713 PyObject *swig_obj[1] ;
12714
12715 if (!args) SWIG_fail;
12716 swig_obj[0] = args;
12717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12718 if (!SWIG_IsOK(res1)) {
12719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12720 }
12721 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12722 {
12723 PyThreadState* __tstate = wxPyBeginAllowThreads();
12724 result = (arg1)->FindNext();
12725 wxPyEndAllowThreads(__tstate);
12726 if (PyErr_Occurred()) SWIG_fail;
12727 }
12728 {
12729 #if wxUSE_UNICODE
12730 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12731 #else
12732 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12733 #endif
12734 }
12735 return resultobj;
12736 fail:
12737 return NULL;
12738 }
12739
12740
12741 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12742 PyObject *resultobj = 0;
12743 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12744 wxString *arg2 = 0 ;
12745 wxString result;
12746 void *argp1 = 0 ;
12747 int res1 = 0 ;
12748 bool temp2 = false ;
12749 PyObject * obj0 = 0 ;
12750 PyObject * obj1 = 0 ;
12751 char * kwnames[] = {
12752 (char *) "self",(char *) "location", NULL
12753 };
12754
12755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12757 if (!SWIG_IsOK(res1)) {
12758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12759 }
12760 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12761 {
12762 arg2 = wxString_in_helper(obj1);
12763 if (arg2 == NULL) SWIG_fail;
12764 temp2 = true;
12765 }
12766 {
12767 PyThreadState* __tstate = wxPyBeginAllowThreads();
12768 result = (arg1)->GetProtocol((wxString const &)*arg2);
12769 wxPyEndAllowThreads(__tstate);
12770 if (PyErr_Occurred()) SWIG_fail;
12771 }
12772 {
12773 #if wxUSE_UNICODE
12774 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12775 #else
12776 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12777 #endif
12778 }
12779 {
12780 if (temp2)
12781 delete arg2;
12782 }
12783 return resultobj;
12784 fail:
12785 {
12786 if (temp2)
12787 delete arg2;
12788 }
12789 return NULL;
12790 }
12791
12792
12793 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12794 PyObject *resultobj = 0;
12795 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12796 wxString *arg2 = 0 ;
12797 wxString result;
12798 void *argp1 = 0 ;
12799 int res1 = 0 ;
12800 bool temp2 = false ;
12801 PyObject * obj0 = 0 ;
12802 PyObject * obj1 = 0 ;
12803 char * kwnames[] = {
12804 (char *) "self",(char *) "location", NULL
12805 };
12806
12807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12809 if (!SWIG_IsOK(res1)) {
12810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12811 }
12812 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12813 {
12814 arg2 = wxString_in_helper(obj1);
12815 if (arg2 == NULL) SWIG_fail;
12816 temp2 = true;
12817 }
12818 {
12819 PyThreadState* __tstate = wxPyBeginAllowThreads();
12820 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12821 wxPyEndAllowThreads(__tstate);
12822 if (PyErr_Occurred()) SWIG_fail;
12823 }
12824 {
12825 #if wxUSE_UNICODE
12826 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12827 #else
12828 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12829 #endif
12830 }
12831 {
12832 if (temp2)
12833 delete arg2;
12834 }
12835 return resultobj;
12836 fail:
12837 {
12838 if (temp2)
12839 delete arg2;
12840 }
12841 return NULL;
12842 }
12843
12844
12845 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12846 PyObject *resultobj = 0;
12847 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12848 wxString *arg2 = 0 ;
12849 wxString result;
12850 void *argp1 = 0 ;
12851 int res1 = 0 ;
12852 bool temp2 = false ;
12853 PyObject * obj0 = 0 ;
12854 PyObject * obj1 = 0 ;
12855 char * kwnames[] = {
12856 (char *) "self",(char *) "location", NULL
12857 };
12858
12859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12861 if (!SWIG_IsOK(res1)) {
12862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12863 }
12864 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12865 {
12866 arg2 = wxString_in_helper(obj1);
12867 if (arg2 == NULL) SWIG_fail;
12868 temp2 = true;
12869 }
12870 {
12871 PyThreadState* __tstate = wxPyBeginAllowThreads();
12872 result = (arg1)->GetAnchor((wxString const &)*arg2);
12873 wxPyEndAllowThreads(__tstate);
12874 if (PyErr_Occurred()) SWIG_fail;
12875 }
12876 {
12877 #if wxUSE_UNICODE
12878 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12879 #else
12880 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12881 #endif
12882 }
12883 {
12884 if (temp2)
12885 delete arg2;
12886 }
12887 return resultobj;
12888 fail:
12889 {
12890 if (temp2)
12891 delete arg2;
12892 }
12893 return NULL;
12894 }
12895
12896
12897 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12898 PyObject *resultobj = 0;
12899 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12900 wxString *arg2 = 0 ;
12901 wxString result;
12902 void *argp1 = 0 ;
12903 int res1 = 0 ;
12904 bool temp2 = false ;
12905 PyObject * obj0 = 0 ;
12906 PyObject * obj1 = 0 ;
12907 char * kwnames[] = {
12908 (char *) "self",(char *) "location", NULL
12909 };
12910
12911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12913 if (!SWIG_IsOK(res1)) {
12914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12915 }
12916 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12917 {
12918 arg2 = wxString_in_helper(obj1);
12919 if (arg2 == NULL) SWIG_fail;
12920 temp2 = true;
12921 }
12922 {
12923 PyThreadState* __tstate = wxPyBeginAllowThreads();
12924 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12925 wxPyEndAllowThreads(__tstate);
12926 if (PyErr_Occurred()) SWIG_fail;
12927 }
12928 {
12929 #if wxUSE_UNICODE
12930 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12931 #else
12932 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12933 #endif
12934 }
12935 {
12936 if (temp2)
12937 delete arg2;
12938 }
12939 return resultobj;
12940 fail:
12941 {
12942 if (temp2)
12943 delete arg2;
12944 }
12945 return NULL;
12946 }
12947
12948
12949 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12950 PyObject *resultobj = 0;
12951 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12952 wxString *arg2 = 0 ;
12953 wxString result;
12954 void *argp1 = 0 ;
12955 int res1 = 0 ;
12956 bool temp2 = false ;
12957 PyObject * obj0 = 0 ;
12958 PyObject * obj1 = 0 ;
12959 char * kwnames[] = {
12960 (char *) "self",(char *) "location", NULL
12961 };
12962
12963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
12964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12965 if (!SWIG_IsOK(res1)) {
12966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12967 }
12968 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12969 {
12970 arg2 = wxString_in_helper(obj1);
12971 if (arg2 == NULL) SWIG_fail;
12972 temp2 = true;
12973 }
12974 {
12975 PyThreadState* __tstate = wxPyBeginAllowThreads();
12976 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
12977 wxPyEndAllowThreads(__tstate);
12978 if (PyErr_Occurred()) SWIG_fail;
12979 }
12980 {
12981 #if wxUSE_UNICODE
12982 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12983 #else
12984 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12985 #endif
12986 }
12987 {
12988 if (temp2)
12989 delete arg2;
12990 }
12991 return resultobj;
12992 fail:
12993 {
12994 if (temp2)
12995 delete arg2;
12996 }
12997 return NULL;
12998 }
12999
13000
13001 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13002 PyObject *obj;
13003 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13004 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
13005 return SWIG_Py_Void();
13006 }
13007
13008 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13009 return SWIG_Python_InitShadowInstance(args);
13010 }
13011
13012 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13013 PyObject *resultobj = 0;
13014 wxFileSystem *result = 0 ;
13015
13016 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13017 {
13018 PyThreadState* __tstate = wxPyBeginAllowThreads();
13019 result = (wxFileSystem *)new wxFileSystem();
13020 wxPyEndAllowThreads(__tstate);
13021 if (PyErr_Occurred()) SWIG_fail;
13022 }
13023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13024 return resultobj;
13025 fail:
13026 return NULL;
13027 }
13028
13029
13030 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13031 PyObject *resultobj = 0;
13032 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13033 void *argp1 = 0 ;
13034 int res1 = 0 ;
13035 PyObject *swig_obj[1] ;
13036
13037 if (!args) SWIG_fail;
13038 swig_obj[0] = args;
13039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13040 if (!SWIG_IsOK(res1)) {
13041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13042 }
13043 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13044 {
13045 PyThreadState* __tstate = wxPyBeginAllowThreads();
13046 delete arg1;
13047
13048 wxPyEndAllowThreads(__tstate);
13049 if (PyErr_Occurred()) SWIG_fail;
13050 }
13051 resultobj = SWIG_Py_Void();
13052 return resultobj;
13053 fail:
13054 return NULL;
13055 }
13056
13057
13058 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13059 PyObject *resultobj = 0;
13060 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13061 wxString *arg2 = 0 ;
13062 bool arg3 = (bool) false ;
13063 void *argp1 = 0 ;
13064 int res1 = 0 ;
13065 bool temp2 = false ;
13066 bool val3 ;
13067 int ecode3 = 0 ;
13068 PyObject * obj0 = 0 ;
13069 PyObject * obj1 = 0 ;
13070 PyObject * obj2 = 0 ;
13071 char * kwnames[] = {
13072 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13073 };
13074
13075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13077 if (!SWIG_IsOK(res1)) {
13078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13079 }
13080 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13081 {
13082 arg2 = wxString_in_helper(obj1);
13083 if (arg2 == NULL) SWIG_fail;
13084 temp2 = true;
13085 }
13086 if (obj2) {
13087 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13088 if (!SWIG_IsOK(ecode3)) {
13089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13090 }
13091 arg3 = static_cast< bool >(val3);
13092 }
13093 {
13094 PyThreadState* __tstate = wxPyBeginAllowThreads();
13095 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13096 wxPyEndAllowThreads(__tstate);
13097 if (PyErr_Occurred()) SWIG_fail;
13098 }
13099 resultobj = SWIG_Py_Void();
13100 {
13101 if (temp2)
13102 delete arg2;
13103 }
13104 return resultobj;
13105 fail:
13106 {
13107 if (temp2)
13108 delete arg2;
13109 }
13110 return NULL;
13111 }
13112
13113
13114 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13115 PyObject *resultobj = 0;
13116 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13117 wxString result;
13118 void *argp1 = 0 ;
13119 int res1 = 0 ;
13120 PyObject *swig_obj[1] ;
13121
13122 if (!args) SWIG_fail;
13123 swig_obj[0] = args;
13124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13125 if (!SWIG_IsOK(res1)) {
13126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13127 }
13128 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13129 {
13130 PyThreadState* __tstate = wxPyBeginAllowThreads();
13131 result = (arg1)->GetPath();
13132 wxPyEndAllowThreads(__tstate);
13133 if (PyErr_Occurred()) SWIG_fail;
13134 }
13135 {
13136 #if wxUSE_UNICODE
13137 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13138 #else
13139 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13140 #endif
13141 }
13142 return resultobj;
13143 fail:
13144 return NULL;
13145 }
13146
13147
13148 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13149 PyObject *resultobj = 0;
13150 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13151 wxString *arg2 = 0 ;
13152 wxFSFile *result = 0 ;
13153 void *argp1 = 0 ;
13154 int res1 = 0 ;
13155 bool temp2 = false ;
13156 PyObject * obj0 = 0 ;
13157 PyObject * obj1 = 0 ;
13158 char * kwnames[] = {
13159 (char *) "self",(char *) "location", NULL
13160 };
13161
13162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13164 if (!SWIG_IsOK(res1)) {
13165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13166 }
13167 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13168 {
13169 arg2 = wxString_in_helper(obj1);
13170 if (arg2 == NULL) SWIG_fail;
13171 temp2 = true;
13172 }
13173 {
13174 PyThreadState* __tstate = wxPyBeginAllowThreads();
13175 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13176 wxPyEndAllowThreads(__tstate);
13177 if (PyErr_Occurred()) SWIG_fail;
13178 }
13179 {
13180 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13181 }
13182 {
13183 if (temp2)
13184 delete arg2;
13185 }
13186 return resultobj;
13187 fail:
13188 {
13189 if (temp2)
13190 delete arg2;
13191 }
13192 return NULL;
13193 }
13194
13195
13196 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13197 PyObject *resultobj = 0;
13198 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13199 wxString *arg2 = 0 ;
13200 int arg3 = (int) 0 ;
13201 wxString result;
13202 void *argp1 = 0 ;
13203 int res1 = 0 ;
13204 bool temp2 = false ;
13205 int val3 ;
13206 int ecode3 = 0 ;
13207 PyObject * obj0 = 0 ;
13208 PyObject * obj1 = 0 ;
13209 PyObject * obj2 = 0 ;
13210 char * kwnames[] = {
13211 (char *) "self",(char *) "spec",(char *) "flags", NULL
13212 };
13213
13214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13216 if (!SWIG_IsOK(res1)) {
13217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13218 }
13219 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13220 {
13221 arg2 = wxString_in_helper(obj1);
13222 if (arg2 == NULL) SWIG_fail;
13223 temp2 = true;
13224 }
13225 if (obj2) {
13226 ecode3 = SWIG_AsVal_int(obj2, &val3);
13227 if (!SWIG_IsOK(ecode3)) {
13228 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13229 }
13230 arg3 = static_cast< int >(val3);
13231 }
13232 {
13233 PyThreadState* __tstate = wxPyBeginAllowThreads();
13234 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13235 wxPyEndAllowThreads(__tstate);
13236 if (PyErr_Occurred()) SWIG_fail;
13237 }
13238 {
13239 #if wxUSE_UNICODE
13240 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13241 #else
13242 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13243 #endif
13244 }
13245 {
13246 if (temp2)
13247 delete arg2;
13248 }
13249 return resultobj;
13250 fail:
13251 {
13252 if (temp2)
13253 delete arg2;
13254 }
13255 return NULL;
13256 }
13257
13258
13259 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13260 PyObject *resultobj = 0;
13261 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13262 wxString result;
13263 void *argp1 = 0 ;
13264 int res1 = 0 ;
13265 PyObject *swig_obj[1] ;
13266
13267 if (!args) SWIG_fail;
13268 swig_obj[0] = args;
13269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13270 if (!SWIG_IsOK(res1)) {
13271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13272 }
13273 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13274 {
13275 PyThreadState* __tstate = wxPyBeginAllowThreads();
13276 result = (arg1)->FindNext();
13277 wxPyEndAllowThreads(__tstate);
13278 if (PyErr_Occurred()) SWIG_fail;
13279 }
13280 {
13281 #if wxUSE_UNICODE
13282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13283 #else
13284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13285 #endif
13286 }
13287 return resultobj;
13288 fail:
13289 return NULL;
13290 }
13291
13292
13293 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13294 PyObject *resultobj = 0;
13295 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13296 int res1 = 0 ;
13297 PyObject * obj0 = 0 ;
13298 char * kwnames[] = {
13299 (char *) "handler", NULL
13300 };
13301
13302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13303 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13304 if (!SWIG_IsOK(res1)) {
13305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13306 }
13307 {
13308 PyThreadState* __tstate = wxPyBeginAllowThreads();
13309 wxFileSystem::AddHandler(arg1);
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_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13321 PyObject *resultobj = 0;
13322 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13323 wxFileSystemHandler *result = 0 ;
13324 void *argp1 = 0 ;
13325 int res1 = 0 ;
13326 PyObject * obj0 = 0 ;
13327 char * kwnames[] = {
13328 (char *) "handler", NULL
13329 };
13330
13331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13333 if (!SWIG_IsOK(res1)) {
13334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13335 }
13336 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13337 {
13338 PyThreadState* __tstate = wxPyBeginAllowThreads();
13339 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13340 wxPyEndAllowThreads(__tstate);
13341 if (PyErr_Occurred()) SWIG_fail;
13342 }
13343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13344 return resultobj;
13345 fail:
13346 return NULL;
13347 }
13348
13349
13350 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13351 PyObject *resultobj = 0;
13352
13353 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13354 {
13355 PyThreadState* __tstate = wxPyBeginAllowThreads();
13356 wxFileSystem::CleanUpHandlers();
13357 wxPyEndAllowThreads(__tstate);
13358 if (PyErr_Occurred()) SWIG_fail;
13359 }
13360 resultobj = SWIG_Py_Void();
13361 return resultobj;
13362 fail:
13363 return NULL;
13364 }
13365
13366
13367 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13368 PyObject *resultobj = 0;
13369 wxString *arg1 = 0 ;
13370 wxString result;
13371 bool temp1 = false ;
13372 PyObject * obj0 = 0 ;
13373 char * kwnames[] = {
13374 (char *) "filename", NULL
13375 };
13376
13377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13378 {
13379 arg1 = wxString_in_helper(obj0);
13380 if (arg1 == NULL) SWIG_fail;
13381 temp1 = true;
13382 }
13383 {
13384 PyThreadState* __tstate = wxPyBeginAllowThreads();
13385 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13386 wxPyEndAllowThreads(__tstate);
13387 if (PyErr_Occurred()) SWIG_fail;
13388 }
13389 {
13390 #if wxUSE_UNICODE
13391 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13392 #else
13393 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13394 #endif
13395 }
13396 {
13397 if (temp1)
13398 delete arg1;
13399 }
13400 return resultobj;
13401 fail:
13402 {
13403 if (temp1)
13404 delete arg1;
13405 }
13406 return NULL;
13407 }
13408
13409
13410 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13411 PyObject *resultobj = 0;
13412 wxString *arg1 = 0 ;
13413 wxString result;
13414 bool temp1 = false ;
13415 PyObject * obj0 = 0 ;
13416 char * kwnames[] = {
13417 (char *) "url", NULL
13418 };
13419
13420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13421 {
13422 arg1 = wxString_in_helper(obj0);
13423 if (arg1 == NULL) SWIG_fail;
13424 temp1 = true;
13425 }
13426 {
13427 PyThreadState* __tstate = wxPyBeginAllowThreads();
13428 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
13429 wxPyEndAllowThreads(__tstate);
13430 if (PyErr_Occurred()) SWIG_fail;
13431 }
13432 {
13433 #if wxUSE_UNICODE
13434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13435 #else
13436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13437 #endif
13438 }
13439 {
13440 if (temp1)
13441 delete arg1;
13442 }
13443 return resultobj;
13444 fail:
13445 {
13446 if (temp1)
13447 delete arg1;
13448 }
13449 return NULL;
13450 }
13451
13452
13453 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13454 PyObject *obj;
13455 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13456 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13457 return SWIG_Py_Void();
13458 }
13459
13460 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13461 return SWIG_Python_InitShadowInstance(args);
13462 }
13463
13464 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13465 PyObject *resultobj = 0;
13466 wxInternetFSHandler *result = 0 ;
13467
13468 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13469 {
13470 PyThreadState* __tstate = wxPyBeginAllowThreads();
13471 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13472 wxPyEndAllowThreads(__tstate);
13473 if (PyErr_Occurred()) SWIG_fail;
13474 }
13475 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13476 return resultobj;
13477 fail:
13478 return NULL;
13479 }
13480
13481
13482 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13483 PyObject *resultobj = 0;
13484 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13485 wxString *arg2 = 0 ;
13486 bool result;
13487 void *argp1 = 0 ;
13488 int res1 = 0 ;
13489 bool temp2 = false ;
13490 PyObject * obj0 = 0 ;
13491 PyObject * obj1 = 0 ;
13492 char * kwnames[] = {
13493 (char *) "self",(char *) "location", NULL
13494 };
13495
13496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13498 if (!SWIG_IsOK(res1)) {
13499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13500 }
13501 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13502 {
13503 arg2 = wxString_in_helper(obj1);
13504 if (arg2 == NULL) SWIG_fail;
13505 temp2 = true;
13506 }
13507 {
13508 PyThreadState* __tstate = wxPyBeginAllowThreads();
13509 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13510 wxPyEndAllowThreads(__tstate);
13511 if (PyErr_Occurred()) SWIG_fail;
13512 }
13513 {
13514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13515 }
13516 {
13517 if (temp2)
13518 delete arg2;
13519 }
13520 return resultobj;
13521 fail:
13522 {
13523 if (temp2)
13524 delete arg2;
13525 }
13526 return NULL;
13527 }
13528
13529
13530 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13531 PyObject *resultobj = 0;
13532 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13533 wxFileSystem *arg2 = 0 ;
13534 wxString *arg3 = 0 ;
13535 wxFSFile *result = 0 ;
13536 void *argp1 = 0 ;
13537 int res1 = 0 ;
13538 void *argp2 = 0 ;
13539 int res2 = 0 ;
13540 bool temp3 = false ;
13541 PyObject * obj0 = 0 ;
13542 PyObject * obj1 = 0 ;
13543 PyObject * obj2 = 0 ;
13544 char * kwnames[] = {
13545 (char *) "self",(char *) "fs",(char *) "location", NULL
13546 };
13547
13548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13550 if (!SWIG_IsOK(res1)) {
13551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13552 }
13553 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13554 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13555 if (!SWIG_IsOK(res2)) {
13556 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13557 }
13558 if (!argp2) {
13559 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13560 }
13561 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13562 {
13563 arg3 = wxString_in_helper(obj2);
13564 if (arg3 == NULL) SWIG_fail;
13565 temp3 = true;
13566 }
13567 {
13568 PyThreadState* __tstate = wxPyBeginAllowThreads();
13569 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13570 wxPyEndAllowThreads(__tstate);
13571 if (PyErr_Occurred()) SWIG_fail;
13572 }
13573 {
13574 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13575 }
13576 {
13577 if (temp3)
13578 delete arg3;
13579 }
13580 return resultobj;
13581 fail:
13582 {
13583 if (temp3)
13584 delete arg3;
13585 }
13586 return NULL;
13587 }
13588
13589
13590 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13591 PyObject *obj;
13592 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13593 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13594 return SWIG_Py_Void();
13595 }
13596
13597 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13598 return SWIG_Python_InitShadowInstance(args);
13599 }
13600
13601 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13602 PyObject *resultobj = 0;
13603 wxZipFSHandler *result = 0 ;
13604
13605 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13606 {
13607 PyThreadState* __tstate = wxPyBeginAllowThreads();
13608 result = (wxZipFSHandler *)new wxZipFSHandler();
13609 wxPyEndAllowThreads(__tstate);
13610 if (PyErr_Occurred()) SWIG_fail;
13611 }
13612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13613 return resultobj;
13614 fail:
13615 return NULL;
13616 }
13617
13618
13619 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13620 PyObject *resultobj = 0;
13621 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13622 wxString *arg2 = 0 ;
13623 bool result;
13624 void *argp1 = 0 ;
13625 int res1 = 0 ;
13626 bool temp2 = false ;
13627 PyObject * obj0 = 0 ;
13628 PyObject * obj1 = 0 ;
13629 char * kwnames[] = {
13630 (char *) "self",(char *) "location", NULL
13631 };
13632
13633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13635 if (!SWIG_IsOK(res1)) {
13636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13637 }
13638 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13639 {
13640 arg2 = wxString_in_helper(obj1);
13641 if (arg2 == NULL) SWIG_fail;
13642 temp2 = true;
13643 }
13644 {
13645 PyThreadState* __tstate = wxPyBeginAllowThreads();
13646 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13647 wxPyEndAllowThreads(__tstate);
13648 if (PyErr_Occurred()) SWIG_fail;
13649 }
13650 {
13651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13652 }
13653 {
13654 if (temp2)
13655 delete arg2;
13656 }
13657 return resultobj;
13658 fail:
13659 {
13660 if (temp2)
13661 delete arg2;
13662 }
13663 return NULL;
13664 }
13665
13666
13667 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13668 PyObject *resultobj = 0;
13669 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13670 wxFileSystem *arg2 = 0 ;
13671 wxString *arg3 = 0 ;
13672 wxFSFile *result = 0 ;
13673 void *argp1 = 0 ;
13674 int res1 = 0 ;
13675 void *argp2 = 0 ;
13676 int res2 = 0 ;
13677 bool temp3 = false ;
13678 PyObject * obj0 = 0 ;
13679 PyObject * obj1 = 0 ;
13680 PyObject * obj2 = 0 ;
13681 char * kwnames[] = {
13682 (char *) "self",(char *) "fs",(char *) "location", NULL
13683 };
13684
13685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13687 if (!SWIG_IsOK(res1)) {
13688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13689 }
13690 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13691 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13692 if (!SWIG_IsOK(res2)) {
13693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13694 }
13695 if (!argp2) {
13696 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13697 }
13698 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13699 {
13700 arg3 = wxString_in_helper(obj2);
13701 if (arg3 == NULL) SWIG_fail;
13702 temp3 = true;
13703 }
13704 {
13705 PyThreadState* __tstate = wxPyBeginAllowThreads();
13706 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13707 wxPyEndAllowThreads(__tstate);
13708 if (PyErr_Occurred()) SWIG_fail;
13709 }
13710 {
13711 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13712 }
13713 {
13714 if (temp3)
13715 delete arg3;
13716 }
13717 return resultobj;
13718 fail:
13719 {
13720 if (temp3)
13721 delete arg3;
13722 }
13723 return NULL;
13724 }
13725
13726
13727 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13728 PyObject *resultobj = 0;
13729 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13730 wxString *arg2 = 0 ;
13731 int arg3 = (int) 0 ;
13732 wxString result;
13733 void *argp1 = 0 ;
13734 int res1 = 0 ;
13735 bool temp2 = false ;
13736 int val3 ;
13737 int ecode3 = 0 ;
13738 PyObject * obj0 = 0 ;
13739 PyObject * obj1 = 0 ;
13740 PyObject * obj2 = 0 ;
13741 char * kwnames[] = {
13742 (char *) "self",(char *) "spec",(char *) "flags", NULL
13743 };
13744
13745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13747 if (!SWIG_IsOK(res1)) {
13748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13749 }
13750 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13751 {
13752 arg2 = wxString_in_helper(obj1);
13753 if (arg2 == NULL) SWIG_fail;
13754 temp2 = true;
13755 }
13756 if (obj2) {
13757 ecode3 = SWIG_AsVal_int(obj2, &val3);
13758 if (!SWIG_IsOK(ecode3)) {
13759 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13760 }
13761 arg3 = static_cast< int >(val3);
13762 }
13763 {
13764 PyThreadState* __tstate = wxPyBeginAllowThreads();
13765 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13766 wxPyEndAllowThreads(__tstate);
13767 if (PyErr_Occurred()) SWIG_fail;
13768 }
13769 {
13770 #if wxUSE_UNICODE
13771 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13772 #else
13773 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13774 #endif
13775 }
13776 {
13777 if (temp2)
13778 delete arg2;
13779 }
13780 return resultobj;
13781 fail:
13782 {
13783 if (temp2)
13784 delete arg2;
13785 }
13786 return NULL;
13787 }
13788
13789
13790 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13791 PyObject *resultobj = 0;
13792 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13793 wxString result;
13794 void *argp1 = 0 ;
13795 int res1 = 0 ;
13796 PyObject *swig_obj[1] ;
13797
13798 if (!args) SWIG_fail;
13799 swig_obj[0] = args;
13800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13801 if (!SWIG_IsOK(res1)) {
13802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13803 }
13804 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13805 {
13806 PyThreadState* __tstate = wxPyBeginAllowThreads();
13807 result = (arg1)->FindNext();
13808 wxPyEndAllowThreads(__tstate);
13809 if (PyErr_Occurred()) SWIG_fail;
13810 }
13811 {
13812 #if wxUSE_UNICODE
13813 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13814 #else
13815 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13816 #endif
13817 }
13818 return resultobj;
13819 fail:
13820 return NULL;
13821 }
13822
13823
13824 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13825 PyObject *obj;
13826 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13827 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13828 return SWIG_Py_Void();
13829 }
13830
13831 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13832 return SWIG_Python_InitShadowInstance(args);
13833 }
13834
13835 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13836 PyObject *resultobj = 0;
13837 wxString *arg1 = 0 ;
13838 wxImage *arg2 = 0 ;
13839 long arg3 ;
13840 bool temp1 = false ;
13841 void *argp2 = 0 ;
13842 int res2 = 0 ;
13843 long val3 ;
13844 int ecode3 = 0 ;
13845 PyObject * obj0 = 0 ;
13846 PyObject * obj1 = 0 ;
13847 PyObject * obj2 = 0 ;
13848 char * kwnames[] = {
13849 (char *) "filename",(char *) "image",(char *) "type", NULL
13850 };
13851
13852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13853 {
13854 arg1 = wxString_in_helper(obj0);
13855 if (arg1 == NULL) SWIG_fail;
13856 temp1 = true;
13857 }
13858 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13859 if (!SWIG_IsOK(res2)) {
13860 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13861 }
13862 if (!argp2) {
13863 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13864 }
13865 arg2 = reinterpret_cast< wxImage * >(argp2);
13866 ecode3 = SWIG_AsVal_long(obj2, &val3);
13867 if (!SWIG_IsOK(ecode3)) {
13868 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13869 }
13870 arg3 = static_cast< long >(val3);
13871 {
13872 PyThreadState* __tstate = wxPyBeginAllowThreads();
13873 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13874 wxPyEndAllowThreads(__tstate);
13875 if (PyErr_Occurred()) SWIG_fail;
13876 }
13877 resultobj = SWIG_Py_Void();
13878 {
13879 if (temp1)
13880 delete arg1;
13881 }
13882 return resultobj;
13883 fail:
13884 {
13885 if (temp1)
13886 delete arg1;
13887 }
13888 return NULL;
13889 }
13890
13891
13892 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13893 PyObject *resultobj = 0;
13894 wxString *arg1 = 0 ;
13895 wxBitmap *arg2 = 0 ;
13896 long arg3 ;
13897 bool temp1 = false ;
13898 void *argp2 = 0 ;
13899 int res2 = 0 ;
13900 long val3 ;
13901 int ecode3 = 0 ;
13902 PyObject * obj0 = 0 ;
13903 PyObject * obj1 = 0 ;
13904 PyObject * obj2 = 0 ;
13905 char * kwnames[] = {
13906 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13907 };
13908
13909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13910 {
13911 arg1 = wxString_in_helper(obj0);
13912 if (arg1 == NULL) SWIG_fail;
13913 temp1 = true;
13914 }
13915 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13916 if (!SWIG_IsOK(res2)) {
13917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13918 }
13919 if (!argp2) {
13920 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13921 }
13922 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13923 ecode3 = SWIG_AsVal_long(obj2, &val3);
13924 if (!SWIG_IsOK(ecode3)) {
13925 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13926 }
13927 arg3 = static_cast< long >(val3);
13928 {
13929 PyThreadState* __tstate = wxPyBeginAllowThreads();
13930 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
13931 wxPyEndAllowThreads(__tstate);
13932 if (PyErr_Occurred()) SWIG_fail;
13933 }
13934 resultobj = SWIG_Py_Void();
13935 {
13936 if (temp1)
13937 delete arg1;
13938 }
13939 return resultobj;
13940 fail:
13941 {
13942 if (temp1)
13943 delete arg1;
13944 }
13945 return NULL;
13946 }
13947
13948
13949 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13950 PyObject *resultobj = 0;
13951 wxString *arg1 = 0 ;
13952 PyObject *arg2 = (PyObject *) 0 ;
13953 bool temp1 = false ;
13954 PyObject * obj0 = 0 ;
13955 PyObject * obj1 = 0 ;
13956 char * kwnames[] = {
13957 (char *) "filename",(char *) "data", NULL
13958 };
13959
13960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
13961 {
13962 arg1 = wxString_in_helper(obj0);
13963 if (arg1 == NULL) SWIG_fail;
13964 temp1 = true;
13965 }
13966 arg2 = obj1;
13967 {
13968 PyThreadState* __tstate = wxPyBeginAllowThreads();
13969 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
13970 wxPyEndAllowThreads(__tstate);
13971 if (PyErr_Occurred()) SWIG_fail;
13972 }
13973 resultobj = SWIG_Py_Void();
13974 {
13975 if (temp1)
13976 delete arg1;
13977 }
13978 return resultobj;
13979 fail:
13980 {
13981 if (temp1)
13982 delete arg1;
13983 }
13984 return NULL;
13985 }
13986
13987
13988 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13989 PyObject *resultobj = 0;
13990 wxMemoryFSHandler *result = 0 ;
13991
13992 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
13993 {
13994 PyThreadState* __tstate = wxPyBeginAllowThreads();
13995 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
13996 wxPyEndAllowThreads(__tstate);
13997 if (PyErr_Occurred()) SWIG_fail;
13998 }
13999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
14000 return resultobj;
14001 fail:
14002 return NULL;
14003 }
14004
14005
14006 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14007 PyObject *resultobj = 0;
14008 wxString *arg1 = 0 ;
14009 bool temp1 = false ;
14010 PyObject * obj0 = 0 ;
14011 char * kwnames[] = {
14012 (char *) "filename", NULL
14013 };
14014
14015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14016 {
14017 arg1 = wxString_in_helper(obj0);
14018 if (arg1 == NULL) SWIG_fail;
14019 temp1 = true;
14020 }
14021 {
14022 PyThreadState* __tstate = wxPyBeginAllowThreads();
14023 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14024 wxPyEndAllowThreads(__tstate);
14025 if (PyErr_Occurred()) SWIG_fail;
14026 }
14027 resultobj = SWIG_Py_Void();
14028 {
14029 if (temp1)
14030 delete arg1;
14031 }
14032 return resultobj;
14033 fail:
14034 {
14035 if (temp1)
14036 delete arg1;
14037 }
14038 return NULL;
14039 }
14040
14041
14042 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14043 PyObject *resultobj = 0;
14044 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14045 wxString *arg2 = 0 ;
14046 bool result;
14047 void *argp1 = 0 ;
14048 int res1 = 0 ;
14049 bool temp2 = false ;
14050 PyObject * obj0 = 0 ;
14051 PyObject * obj1 = 0 ;
14052 char * kwnames[] = {
14053 (char *) "self",(char *) "location", NULL
14054 };
14055
14056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14058 if (!SWIG_IsOK(res1)) {
14059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14060 }
14061 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14062 {
14063 arg2 = wxString_in_helper(obj1);
14064 if (arg2 == NULL) SWIG_fail;
14065 temp2 = true;
14066 }
14067 {
14068 PyThreadState* __tstate = wxPyBeginAllowThreads();
14069 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14070 wxPyEndAllowThreads(__tstate);
14071 if (PyErr_Occurred()) SWIG_fail;
14072 }
14073 {
14074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14075 }
14076 {
14077 if (temp2)
14078 delete arg2;
14079 }
14080 return resultobj;
14081 fail:
14082 {
14083 if (temp2)
14084 delete arg2;
14085 }
14086 return NULL;
14087 }
14088
14089
14090 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14091 PyObject *resultobj = 0;
14092 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14093 wxFileSystem *arg2 = 0 ;
14094 wxString *arg3 = 0 ;
14095 wxFSFile *result = 0 ;
14096 void *argp1 = 0 ;
14097 int res1 = 0 ;
14098 void *argp2 = 0 ;
14099 int res2 = 0 ;
14100 bool temp3 = false ;
14101 PyObject * obj0 = 0 ;
14102 PyObject * obj1 = 0 ;
14103 PyObject * obj2 = 0 ;
14104 char * kwnames[] = {
14105 (char *) "self",(char *) "fs",(char *) "location", NULL
14106 };
14107
14108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14110 if (!SWIG_IsOK(res1)) {
14111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14112 }
14113 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14114 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14115 if (!SWIG_IsOK(res2)) {
14116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14117 }
14118 if (!argp2) {
14119 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14120 }
14121 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14122 {
14123 arg3 = wxString_in_helper(obj2);
14124 if (arg3 == NULL) SWIG_fail;
14125 temp3 = true;
14126 }
14127 {
14128 PyThreadState* __tstate = wxPyBeginAllowThreads();
14129 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14130 wxPyEndAllowThreads(__tstate);
14131 if (PyErr_Occurred()) SWIG_fail;
14132 }
14133 {
14134 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14135 }
14136 {
14137 if (temp3)
14138 delete arg3;
14139 }
14140 return resultobj;
14141 fail:
14142 {
14143 if (temp3)
14144 delete arg3;
14145 }
14146 return NULL;
14147 }
14148
14149
14150 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14151 PyObject *resultobj = 0;
14152 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14153 wxString *arg2 = 0 ;
14154 int arg3 = (int) 0 ;
14155 wxString result;
14156 void *argp1 = 0 ;
14157 int res1 = 0 ;
14158 bool temp2 = false ;
14159 int val3 ;
14160 int ecode3 = 0 ;
14161 PyObject * obj0 = 0 ;
14162 PyObject * obj1 = 0 ;
14163 PyObject * obj2 = 0 ;
14164 char * kwnames[] = {
14165 (char *) "self",(char *) "spec",(char *) "flags", NULL
14166 };
14167
14168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14170 if (!SWIG_IsOK(res1)) {
14171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14172 }
14173 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14174 {
14175 arg2 = wxString_in_helper(obj1);
14176 if (arg2 == NULL) SWIG_fail;
14177 temp2 = true;
14178 }
14179 if (obj2) {
14180 ecode3 = SWIG_AsVal_int(obj2, &val3);
14181 if (!SWIG_IsOK(ecode3)) {
14182 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14183 }
14184 arg3 = static_cast< int >(val3);
14185 }
14186 {
14187 PyThreadState* __tstate = wxPyBeginAllowThreads();
14188 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14189 wxPyEndAllowThreads(__tstate);
14190 if (PyErr_Occurred()) SWIG_fail;
14191 }
14192 {
14193 #if wxUSE_UNICODE
14194 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14195 #else
14196 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14197 #endif
14198 }
14199 {
14200 if (temp2)
14201 delete arg2;
14202 }
14203 return resultobj;
14204 fail:
14205 {
14206 if (temp2)
14207 delete arg2;
14208 }
14209 return NULL;
14210 }
14211
14212
14213 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14214 PyObject *resultobj = 0;
14215 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14216 wxString result;
14217 void *argp1 = 0 ;
14218 int res1 = 0 ;
14219 PyObject *swig_obj[1] ;
14220
14221 if (!args) SWIG_fail;
14222 swig_obj[0] = args;
14223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14224 if (!SWIG_IsOK(res1)) {
14225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14226 }
14227 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14228 {
14229 PyThreadState* __tstate = wxPyBeginAllowThreads();
14230 result = (arg1)->FindNext();
14231 wxPyEndAllowThreads(__tstate);
14232 if (PyErr_Occurred()) SWIG_fail;
14233 }
14234 {
14235 #if wxUSE_UNICODE
14236 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14237 #else
14238 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14239 #endif
14240 }
14241 return resultobj;
14242 fail:
14243 return NULL;
14244 }
14245
14246
14247 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14248 PyObject *obj;
14249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14250 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14251 return SWIG_Py_Void();
14252 }
14253
14254 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14255 return SWIG_Python_InitShadowInstance(args);
14256 }
14257
14258 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14259 PyObject *resultobj = 0;
14260 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14261 wxString result;
14262 void *argp1 = 0 ;
14263 int res1 = 0 ;
14264 PyObject *swig_obj[1] ;
14265
14266 if (!args) SWIG_fail;
14267 swig_obj[0] = args;
14268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14269 if (!SWIG_IsOK(res1)) {
14270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14271 }
14272 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14273 {
14274 PyThreadState* __tstate = wxPyBeginAllowThreads();
14275 result = (arg1)->GetName();
14276 wxPyEndAllowThreads(__tstate);
14277 if (PyErr_Occurred()) SWIG_fail;
14278 }
14279 {
14280 #if wxUSE_UNICODE
14281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14282 #else
14283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14284 #endif
14285 }
14286 return resultobj;
14287 fail:
14288 return NULL;
14289 }
14290
14291
14292 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14293 PyObject *resultobj = 0;
14294 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14295 wxString result;
14296 void *argp1 = 0 ;
14297 int res1 = 0 ;
14298 PyObject *swig_obj[1] ;
14299
14300 if (!args) SWIG_fail;
14301 swig_obj[0] = args;
14302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14303 if (!SWIG_IsOK(res1)) {
14304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14305 }
14306 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14307 {
14308 PyThreadState* __tstate = wxPyBeginAllowThreads();
14309 result = (arg1)->GetExtension();
14310 wxPyEndAllowThreads(__tstate);
14311 if (PyErr_Occurred()) SWIG_fail;
14312 }
14313 {
14314 #if wxUSE_UNICODE
14315 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14316 #else
14317 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14318 #endif
14319 }
14320 return resultobj;
14321 fail:
14322 return NULL;
14323 }
14324
14325
14326 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14327 PyObject *resultobj = 0;
14328 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14329 long result;
14330 void *argp1 = 0 ;
14331 int res1 = 0 ;
14332 PyObject *swig_obj[1] ;
14333
14334 if (!args) SWIG_fail;
14335 swig_obj[0] = args;
14336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14337 if (!SWIG_IsOK(res1)) {
14338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14339 }
14340 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14341 {
14342 PyThreadState* __tstate = wxPyBeginAllowThreads();
14343 result = (long)(arg1)->GetType();
14344 wxPyEndAllowThreads(__tstate);
14345 if (PyErr_Occurred()) SWIG_fail;
14346 }
14347 resultobj = SWIG_From_long(static_cast< long >(result));
14348 return resultobj;
14349 fail:
14350 return NULL;
14351 }
14352
14353
14354 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14355 PyObject *resultobj = 0;
14356 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14357 wxString result;
14358 void *argp1 = 0 ;
14359 int res1 = 0 ;
14360 PyObject *swig_obj[1] ;
14361
14362 if (!args) SWIG_fail;
14363 swig_obj[0] = args;
14364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14365 if (!SWIG_IsOK(res1)) {
14366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14367 }
14368 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14369 {
14370 PyThreadState* __tstate = wxPyBeginAllowThreads();
14371 result = (arg1)->GetMimeType();
14372 wxPyEndAllowThreads(__tstate);
14373 if (PyErr_Occurred()) SWIG_fail;
14374 }
14375 {
14376 #if wxUSE_UNICODE
14377 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14378 #else
14379 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14380 #endif
14381 }
14382 return resultobj;
14383 fail:
14384 return NULL;
14385 }
14386
14387
14388 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14389 PyObject *resultobj = 0;
14390 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14391 wxString *arg2 = 0 ;
14392 bool result;
14393 void *argp1 = 0 ;
14394 int res1 = 0 ;
14395 bool temp2 = false ;
14396 PyObject * obj0 = 0 ;
14397 PyObject * obj1 = 0 ;
14398 char * kwnames[] = {
14399 (char *) "self",(char *) "name", NULL
14400 };
14401
14402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14404 if (!SWIG_IsOK(res1)) {
14405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14406 }
14407 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14408 {
14409 arg2 = wxString_in_helper(obj1);
14410 if (arg2 == NULL) SWIG_fail;
14411 temp2 = true;
14412 }
14413 {
14414 PyThreadState* __tstate = wxPyBeginAllowThreads();
14415 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14416 wxPyEndAllowThreads(__tstate);
14417 if (PyErr_Occurred()) SWIG_fail;
14418 }
14419 {
14420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14421 }
14422 {
14423 if (temp2)
14424 delete arg2;
14425 }
14426 return resultobj;
14427 fail:
14428 {
14429 if (temp2)
14430 delete arg2;
14431 }
14432 return NULL;
14433 }
14434
14435
14436 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14437 PyObject *resultobj = 0;
14438 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14439 wxInputStream *arg2 = 0 ;
14440 bool result;
14441 void *argp1 = 0 ;
14442 int res1 = 0 ;
14443 wxPyInputStream *temp2 ;
14444 bool created2 ;
14445 PyObject * obj0 = 0 ;
14446 PyObject * obj1 = 0 ;
14447 char * kwnames[] = {
14448 (char *) "self",(char *) "stream", NULL
14449 };
14450
14451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14453 if (!SWIG_IsOK(res1)) {
14454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14455 }
14456 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14457 {
14458 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14459 arg2 = temp2->m_wxis;
14460 created2 = false;
14461 } else {
14462 PyErr_Clear(); // clear the failure of the wxPyConvert above
14463 arg2 = wxPyCBInputStream_create(obj1, false);
14464 if (arg2 == NULL) {
14465 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14466 SWIG_fail;
14467 }
14468 created2 = true;
14469 }
14470 }
14471 {
14472 PyThreadState* __tstate = wxPyBeginAllowThreads();
14473 result = (bool)(arg1)->CanRead(*arg2);
14474 wxPyEndAllowThreads(__tstate);
14475 if (PyErr_Occurred()) SWIG_fail;
14476 }
14477 {
14478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14479 }
14480 {
14481 if (created2) delete arg2;
14482 }
14483 return resultobj;
14484 fail:
14485 {
14486 if (created2) delete arg2;
14487 }
14488 return NULL;
14489 }
14490
14491
14492 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14493 PyObject *resultobj = 0;
14494 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14495 wxString *arg2 = 0 ;
14496 void *argp1 = 0 ;
14497 int res1 = 0 ;
14498 bool temp2 = false ;
14499 PyObject * obj0 = 0 ;
14500 PyObject * obj1 = 0 ;
14501 char * kwnames[] = {
14502 (char *) "self",(char *) "name", NULL
14503 };
14504
14505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14507 if (!SWIG_IsOK(res1)) {
14508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14509 }
14510 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14511 {
14512 arg2 = wxString_in_helper(obj1);
14513 if (arg2 == NULL) SWIG_fail;
14514 temp2 = true;
14515 }
14516 {
14517 PyThreadState* __tstate = wxPyBeginAllowThreads();
14518 (arg1)->SetName((wxString const &)*arg2);
14519 wxPyEndAllowThreads(__tstate);
14520 if (PyErr_Occurred()) SWIG_fail;
14521 }
14522 resultobj = SWIG_Py_Void();
14523 {
14524 if (temp2)
14525 delete arg2;
14526 }
14527 return resultobj;
14528 fail:
14529 {
14530 if (temp2)
14531 delete arg2;
14532 }
14533 return NULL;
14534 }
14535
14536
14537 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14538 PyObject *resultobj = 0;
14539 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14540 wxString *arg2 = 0 ;
14541 void *argp1 = 0 ;
14542 int res1 = 0 ;
14543 bool temp2 = false ;
14544 PyObject * obj0 = 0 ;
14545 PyObject * obj1 = 0 ;
14546 char * kwnames[] = {
14547 (char *) "self",(char *) "extension", NULL
14548 };
14549
14550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
14551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14552 if (!SWIG_IsOK(res1)) {
14553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14554 }
14555 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14556 {
14557 arg2 = wxString_in_helper(obj1);
14558 if (arg2 == NULL) SWIG_fail;
14559 temp2 = true;
14560 }
14561 {
14562 PyThreadState* __tstate = wxPyBeginAllowThreads();
14563 (arg1)->SetExtension((wxString const &)*arg2);
14564 wxPyEndAllowThreads(__tstate);
14565 if (PyErr_Occurred()) SWIG_fail;
14566 }
14567 resultobj = SWIG_Py_Void();
14568 {
14569 if (temp2)
14570 delete arg2;
14571 }
14572 return resultobj;
14573 fail:
14574 {
14575 if (temp2)
14576 delete arg2;
14577 }
14578 return NULL;
14579 }
14580
14581
14582 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14583 PyObject *resultobj = 0;
14584 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14585 long arg2 ;
14586 void *argp1 = 0 ;
14587 int res1 = 0 ;
14588 long val2 ;
14589 int ecode2 = 0 ;
14590 PyObject * obj0 = 0 ;
14591 PyObject * obj1 = 0 ;
14592 char * kwnames[] = {
14593 (char *) "self",(char *) "type", NULL
14594 };
14595
14596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14598 if (!SWIG_IsOK(res1)) {
14599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14600 }
14601 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14602 ecode2 = SWIG_AsVal_long(obj1, &val2);
14603 if (!SWIG_IsOK(ecode2)) {
14604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14605 }
14606 arg2 = static_cast< long >(val2);
14607 {
14608 PyThreadState* __tstate = wxPyBeginAllowThreads();
14609 (arg1)->SetType(arg2);
14610 wxPyEndAllowThreads(__tstate);
14611 if (PyErr_Occurred()) SWIG_fail;
14612 }
14613 resultobj = SWIG_Py_Void();
14614 return resultobj;
14615 fail:
14616 return NULL;
14617 }
14618
14619
14620 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14621 PyObject *resultobj = 0;
14622 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14623 wxString *arg2 = 0 ;
14624 void *argp1 = 0 ;
14625 int res1 = 0 ;
14626 bool temp2 = false ;
14627 PyObject * obj0 = 0 ;
14628 PyObject * obj1 = 0 ;
14629 char * kwnames[] = {
14630 (char *) "self",(char *) "mimetype", NULL
14631 };
14632
14633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14635 if (!SWIG_IsOK(res1)) {
14636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14637 }
14638 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14639 {
14640 arg2 = wxString_in_helper(obj1);
14641 if (arg2 == NULL) SWIG_fail;
14642 temp2 = true;
14643 }
14644 {
14645 PyThreadState* __tstate = wxPyBeginAllowThreads();
14646 (arg1)->SetMimeType((wxString const &)*arg2);
14647 wxPyEndAllowThreads(__tstate);
14648 if (PyErr_Occurred()) SWIG_fail;
14649 }
14650 resultobj = SWIG_Py_Void();
14651 {
14652 if (temp2)
14653 delete arg2;
14654 }
14655 return resultobj;
14656 fail:
14657 {
14658 if (temp2)
14659 delete arg2;
14660 }
14661 return NULL;
14662 }
14663
14664
14665 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14666 PyObject *obj;
14667 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14668 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14669 return SWIG_Py_Void();
14670 }
14671
14672 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14673 PyObject *resultobj = 0;
14674 wxPyImageHandler *result = 0 ;
14675
14676 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14677 {
14678 PyThreadState* __tstate = wxPyBeginAllowThreads();
14679 result = (wxPyImageHandler *)new wxPyImageHandler();
14680 wxPyEndAllowThreads(__tstate);
14681 if (PyErr_Occurred()) SWIG_fail;
14682 }
14683 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14684 return resultobj;
14685 fail:
14686 return NULL;
14687 }
14688
14689
14690 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14691 PyObject *resultobj = 0;
14692 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14693 PyObject *arg2 = (PyObject *) 0 ;
14694 void *argp1 = 0 ;
14695 int res1 = 0 ;
14696 PyObject * obj0 = 0 ;
14697 PyObject * obj1 = 0 ;
14698 char * kwnames[] = {
14699 (char *) "self",(char *) "self", NULL
14700 };
14701
14702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14704 if (!SWIG_IsOK(res1)) {
14705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14706 }
14707 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14708 arg2 = obj1;
14709 {
14710 PyThreadState* __tstate = wxPyBeginAllowThreads();
14711 (arg1)->_SetSelf(arg2);
14712 wxPyEndAllowThreads(__tstate);
14713 if (PyErr_Occurred()) SWIG_fail;
14714 }
14715 resultobj = SWIG_Py_Void();
14716 return resultobj;
14717 fail:
14718 return NULL;
14719 }
14720
14721
14722 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14723 PyObject *obj;
14724 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14725 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14726 return SWIG_Py_Void();
14727 }
14728
14729 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14730 return SWIG_Python_InitShadowInstance(args);
14731 }
14732
14733 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14734 PyObject *resultobj = 0;
14735 wxImageHistogram *result = 0 ;
14736
14737 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14738 {
14739 PyThreadState* __tstate = wxPyBeginAllowThreads();
14740 result = (wxImageHistogram *)new wxImageHistogram();
14741 wxPyEndAllowThreads(__tstate);
14742 if (PyErr_Occurred()) SWIG_fail;
14743 }
14744 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14745 return resultobj;
14746 fail:
14747 return NULL;
14748 }
14749
14750
14751 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14752 PyObject *resultobj = 0;
14753 byte arg1 ;
14754 byte arg2 ;
14755 byte arg3 ;
14756 unsigned long result;
14757 unsigned char val1 ;
14758 int ecode1 = 0 ;
14759 unsigned char val2 ;
14760 int ecode2 = 0 ;
14761 unsigned char val3 ;
14762 int ecode3 = 0 ;
14763 PyObject * obj0 = 0 ;
14764 PyObject * obj1 = 0 ;
14765 PyObject * obj2 = 0 ;
14766 char * kwnames[] = {
14767 (char *) "r",(char *) "g",(char *) "b", NULL
14768 };
14769
14770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14771 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14772 if (!SWIG_IsOK(ecode1)) {
14773 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14774 }
14775 arg1 = static_cast< byte >(val1);
14776 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14777 if (!SWIG_IsOK(ecode2)) {
14778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14779 }
14780 arg2 = static_cast< byte >(val2);
14781 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14782 if (!SWIG_IsOK(ecode3)) {
14783 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14784 }
14785 arg3 = static_cast< byte >(val3);
14786 {
14787 PyThreadState* __tstate = wxPyBeginAllowThreads();
14788 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14789 wxPyEndAllowThreads(__tstate);
14790 if (PyErr_Occurred()) SWIG_fail;
14791 }
14792 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14793 return resultobj;
14794 fail:
14795 return NULL;
14796 }
14797
14798
14799 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14800 PyObject *resultobj = 0;
14801 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14802 byte *arg2 = (byte *) 0 ;
14803 byte *arg3 = (byte *) 0 ;
14804 byte *arg4 = (byte *) 0 ;
14805 byte arg5 = (byte) 1 ;
14806 byte arg6 = (byte) 0 ;
14807 byte arg7 = (byte) 0 ;
14808 bool result;
14809 void *argp1 = 0 ;
14810 int res1 = 0 ;
14811 byte temp2 ;
14812 int res2 = SWIG_TMPOBJ ;
14813 byte temp3 ;
14814 int res3 = SWIG_TMPOBJ ;
14815 byte temp4 ;
14816 int res4 = SWIG_TMPOBJ ;
14817 unsigned char val5 ;
14818 int ecode5 = 0 ;
14819 unsigned char val6 ;
14820 int ecode6 = 0 ;
14821 unsigned char val7 ;
14822 int ecode7 = 0 ;
14823 PyObject * obj0 = 0 ;
14824 PyObject * obj1 = 0 ;
14825 PyObject * obj2 = 0 ;
14826 PyObject * obj3 = 0 ;
14827 char * kwnames[] = {
14828 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14829 };
14830
14831 arg2 = &temp2;
14832 arg3 = &temp3;
14833 arg4 = &temp4;
14834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14836 if (!SWIG_IsOK(res1)) {
14837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14838 }
14839 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14840 if (obj1) {
14841 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14842 if (!SWIG_IsOK(ecode5)) {
14843 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14844 }
14845 arg5 = static_cast< byte >(val5);
14846 }
14847 if (obj2) {
14848 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14849 if (!SWIG_IsOK(ecode6)) {
14850 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14851 }
14852 arg6 = static_cast< byte >(val6);
14853 }
14854 if (obj3) {
14855 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14856 if (!SWIG_IsOK(ecode7)) {
14857 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14858 }
14859 arg7 = static_cast< byte >(val7);
14860 }
14861 {
14862 PyThreadState* __tstate = wxPyBeginAllowThreads();
14863 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14864 wxPyEndAllowThreads(__tstate);
14865 if (PyErr_Occurred()) SWIG_fail;
14866 }
14867 {
14868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14869 }
14870 if (SWIG_IsTmpObj(res2)) {
14871 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14872 } else {
14873 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14874 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14875 }
14876 if (SWIG_IsTmpObj(res3)) {
14877 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14878 } else {
14879 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14880 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14881 }
14882 if (SWIG_IsTmpObj(res4)) {
14883 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14884 } else {
14885 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14886 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14887 }
14888 return resultobj;
14889 fail:
14890 return NULL;
14891 }
14892
14893
14894 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14895 PyObject *resultobj = 0;
14896 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14897 unsigned long arg2 ;
14898 unsigned long result;
14899 void *argp1 = 0 ;
14900 int res1 = 0 ;
14901 unsigned long val2 ;
14902 int ecode2 = 0 ;
14903 PyObject * obj0 = 0 ;
14904 PyObject * obj1 = 0 ;
14905 char * kwnames[] = {
14906 (char *) "self",(char *) "key", NULL
14907 };
14908
14909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14911 if (!SWIG_IsOK(res1)) {
14912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14913 }
14914 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14915 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14916 if (!SWIG_IsOK(ecode2)) {
14917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14918 }
14919 arg2 = static_cast< unsigned long >(val2);
14920 {
14921 PyThreadState* __tstate = wxPyBeginAllowThreads();
14922 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14923 wxPyEndAllowThreads(__tstate);
14924 if (PyErr_Occurred()) SWIG_fail;
14925 }
14926 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14927 return resultobj;
14928 fail:
14929 return NULL;
14930 }
14931
14932
14933 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14934 PyObject *resultobj = 0;
14935 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14936 byte arg2 ;
14937 byte arg3 ;
14938 byte arg4 ;
14939 unsigned long result;
14940 void *argp1 = 0 ;
14941 int res1 = 0 ;
14942 unsigned char val2 ;
14943 int ecode2 = 0 ;
14944 unsigned char val3 ;
14945 int ecode3 = 0 ;
14946 unsigned char val4 ;
14947 int ecode4 = 0 ;
14948 PyObject * obj0 = 0 ;
14949 PyObject * obj1 = 0 ;
14950 PyObject * obj2 = 0 ;
14951 PyObject * obj3 = 0 ;
14952 char * kwnames[] = {
14953 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14954 };
14955
14956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14958 if (!SWIG_IsOK(res1)) {
14959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14960 }
14961 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14962 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14963 if (!SWIG_IsOK(ecode2)) {
14964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
14965 }
14966 arg2 = static_cast< byte >(val2);
14967 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14968 if (!SWIG_IsOK(ecode3)) {
14969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
14970 }
14971 arg3 = static_cast< byte >(val3);
14972 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14973 if (!SWIG_IsOK(ecode4)) {
14974 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
14975 }
14976 arg4 = static_cast< byte >(val4);
14977 {
14978 PyThreadState* __tstate = wxPyBeginAllowThreads();
14979 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
14980 wxPyEndAllowThreads(__tstate);
14981 if (PyErr_Occurred()) SWIG_fail;
14982 }
14983 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14984 return resultobj;
14985 fail:
14986 return NULL;
14987 }
14988
14989
14990 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14991 PyObject *resultobj = 0;
14992 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14993 wxColour *arg2 = 0 ;
14994 unsigned long result;
14995 void *argp1 = 0 ;
14996 int res1 = 0 ;
14997 wxColour temp2 ;
14998 PyObject * obj0 = 0 ;
14999 PyObject * obj1 = 0 ;
15000 char * kwnames[] = {
15001 (char *) "self",(char *) "colour", NULL
15002 };
15003
15004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
15005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15006 if (!SWIG_IsOK(res1)) {
15007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15008 }
15009 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15010 {
15011 arg2 = &temp2;
15012 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15013 }
15014 {
15015 PyThreadState* __tstate = wxPyBeginAllowThreads();
15016 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15017 wxPyEndAllowThreads(__tstate);
15018 if (PyErr_Occurred()) SWIG_fail;
15019 }
15020 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15021 return resultobj;
15022 fail:
15023 return NULL;
15024 }
15025
15026
15027 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15028 PyObject *obj;
15029 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15030 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15031 return SWIG_Py_Void();
15032 }
15033
15034 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15035 return SWIG_Python_InitShadowInstance(args);
15036 }
15037
15038 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15039 PyObject *resultobj = 0;
15040 byte arg1 = (byte) 0 ;
15041 byte arg2 = (byte) 0 ;
15042 byte arg3 = (byte) 0 ;
15043 wxImage_RGBValue *result = 0 ;
15044 unsigned char val1 ;
15045 int ecode1 = 0 ;
15046 unsigned char val2 ;
15047 int ecode2 = 0 ;
15048 unsigned char val3 ;
15049 int ecode3 = 0 ;
15050 PyObject * obj0 = 0 ;
15051 PyObject * obj1 = 0 ;
15052 PyObject * obj2 = 0 ;
15053 char * kwnames[] = {
15054 (char *) "r",(char *) "g",(char *) "b", NULL
15055 };
15056
15057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15058 if (obj0) {
15059 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15060 if (!SWIG_IsOK(ecode1)) {
15061 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15062 }
15063 arg1 = static_cast< byte >(val1);
15064 }
15065 if (obj1) {
15066 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15067 if (!SWIG_IsOK(ecode2)) {
15068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15069 }
15070 arg2 = static_cast< byte >(val2);
15071 }
15072 if (obj2) {
15073 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15074 if (!SWIG_IsOK(ecode3)) {
15075 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15076 }
15077 arg3 = static_cast< byte >(val3);
15078 }
15079 {
15080 PyThreadState* __tstate = wxPyBeginAllowThreads();
15081 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15082 wxPyEndAllowThreads(__tstate);
15083 if (PyErr_Occurred()) SWIG_fail;
15084 }
15085 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15086 return resultobj;
15087 fail:
15088 return NULL;
15089 }
15090
15091
15092 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15093 PyObject *resultobj = 0;
15094 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15095 byte arg2 ;
15096 void *argp1 = 0 ;
15097 int res1 = 0 ;
15098 unsigned char val2 ;
15099 int ecode2 = 0 ;
15100 PyObject *swig_obj[2] ;
15101
15102 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15104 if (!SWIG_IsOK(res1)) {
15105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15106 }
15107 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15108 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15109 if (!SWIG_IsOK(ecode2)) {
15110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15111 }
15112 arg2 = static_cast< byte >(val2);
15113 if (arg1) (arg1)->red = arg2;
15114
15115 resultobj = SWIG_Py_Void();
15116 return resultobj;
15117 fail:
15118 return NULL;
15119 }
15120
15121
15122 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15123 PyObject *resultobj = 0;
15124 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15125 byte result;
15126 void *argp1 = 0 ;
15127 int res1 = 0 ;
15128 PyObject *swig_obj[1] ;
15129
15130 if (!args) SWIG_fail;
15131 swig_obj[0] = args;
15132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15133 if (!SWIG_IsOK(res1)) {
15134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15135 }
15136 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15137 result = (byte) ((arg1)->red);
15138 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15139 return resultobj;
15140 fail:
15141 return NULL;
15142 }
15143
15144
15145 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15146 PyObject *resultobj = 0;
15147 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15148 byte arg2 ;
15149 void *argp1 = 0 ;
15150 int res1 = 0 ;
15151 unsigned char val2 ;
15152 int ecode2 = 0 ;
15153 PyObject *swig_obj[2] ;
15154
15155 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15157 if (!SWIG_IsOK(res1)) {
15158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15159 }
15160 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15161 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15162 if (!SWIG_IsOK(ecode2)) {
15163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15164 }
15165 arg2 = static_cast< byte >(val2);
15166 if (arg1) (arg1)->green = arg2;
15167
15168 resultobj = SWIG_Py_Void();
15169 return resultobj;
15170 fail:
15171 return NULL;
15172 }
15173
15174
15175 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15176 PyObject *resultobj = 0;
15177 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15178 byte result;
15179 void *argp1 = 0 ;
15180 int res1 = 0 ;
15181 PyObject *swig_obj[1] ;
15182
15183 if (!args) SWIG_fail;
15184 swig_obj[0] = args;
15185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15186 if (!SWIG_IsOK(res1)) {
15187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15188 }
15189 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15190 result = (byte) ((arg1)->green);
15191 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15192 return resultobj;
15193 fail:
15194 return NULL;
15195 }
15196
15197
15198 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15199 PyObject *resultobj = 0;
15200 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15201 byte arg2 ;
15202 void *argp1 = 0 ;
15203 int res1 = 0 ;
15204 unsigned char val2 ;
15205 int ecode2 = 0 ;
15206 PyObject *swig_obj[2] ;
15207
15208 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15210 if (!SWIG_IsOK(res1)) {
15211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15212 }
15213 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15214 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15215 if (!SWIG_IsOK(ecode2)) {
15216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15217 }
15218 arg2 = static_cast< byte >(val2);
15219 if (arg1) (arg1)->blue = arg2;
15220
15221 resultobj = SWIG_Py_Void();
15222 return resultobj;
15223 fail:
15224 return NULL;
15225 }
15226
15227
15228 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15229 PyObject *resultobj = 0;
15230 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15231 byte result;
15232 void *argp1 = 0 ;
15233 int res1 = 0 ;
15234 PyObject *swig_obj[1] ;
15235
15236 if (!args) SWIG_fail;
15237 swig_obj[0] = args;
15238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15239 if (!SWIG_IsOK(res1)) {
15240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15241 }
15242 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15243 result = (byte) ((arg1)->blue);
15244 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15245 return resultobj;
15246 fail:
15247 return NULL;
15248 }
15249
15250
15251 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15252 PyObject *obj;
15253 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15254 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15255 return SWIG_Py_Void();
15256 }
15257
15258 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15259 return SWIG_Python_InitShadowInstance(args);
15260 }
15261
15262 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15263 PyObject *resultobj = 0;
15264 double arg1 = (double) 0.0 ;
15265 double arg2 = (double) 0.0 ;
15266 double arg3 = (double) 0.0 ;
15267 wxImage_HSVValue *result = 0 ;
15268 double val1 ;
15269 int ecode1 = 0 ;
15270 double val2 ;
15271 int ecode2 = 0 ;
15272 double val3 ;
15273 int ecode3 = 0 ;
15274 PyObject * obj0 = 0 ;
15275 PyObject * obj1 = 0 ;
15276 PyObject * obj2 = 0 ;
15277 char * kwnames[] = {
15278 (char *) "h",(char *) "s",(char *) "v", NULL
15279 };
15280
15281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15282 if (obj0) {
15283 ecode1 = SWIG_AsVal_double(obj0, &val1);
15284 if (!SWIG_IsOK(ecode1)) {
15285 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15286 }
15287 arg1 = static_cast< double >(val1);
15288 }
15289 if (obj1) {
15290 ecode2 = SWIG_AsVal_double(obj1, &val2);
15291 if (!SWIG_IsOK(ecode2)) {
15292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15293 }
15294 arg2 = static_cast< double >(val2);
15295 }
15296 if (obj2) {
15297 ecode3 = SWIG_AsVal_double(obj2, &val3);
15298 if (!SWIG_IsOK(ecode3)) {
15299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15300 }
15301 arg3 = static_cast< double >(val3);
15302 }
15303 {
15304 PyThreadState* __tstate = wxPyBeginAllowThreads();
15305 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15306 wxPyEndAllowThreads(__tstate);
15307 if (PyErr_Occurred()) SWIG_fail;
15308 }
15309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15310 return resultobj;
15311 fail:
15312 return NULL;
15313 }
15314
15315
15316 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15317 PyObject *resultobj = 0;
15318 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15319 double arg2 ;
15320 void *argp1 = 0 ;
15321 int res1 = 0 ;
15322 double val2 ;
15323 int ecode2 = 0 ;
15324 PyObject *swig_obj[2] ;
15325
15326 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15328 if (!SWIG_IsOK(res1)) {
15329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15330 }
15331 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15332 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15333 if (!SWIG_IsOK(ecode2)) {
15334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15335 }
15336 arg2 = static_cast< double >(val2);
15337 if (arg1) (arg1)->hue = arg2;
15338
15339 resultobj = SWIG_Py_Void();
15340 return resultobj;
15341 fail:
15342 return NULL;
15343 }
15344
15345
15346 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15347 PyObject *resultobj = 0;
15348 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15349 double result;
15350 void *argp1 = 0 ;
15351 int res1 = 0 ;
15352 PyObject *swig_obj[1] ;
15353
15354 if (!args) SWIG_fail;
15355 swig_obj[0] = args;
15356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15357 if (!SWIG_IsOK(res1)) {
15358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15359 }
15360 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15361 result = (double) ((arg1)->hue);
15362 resultobj = SWIG_From_double(static_cast< double >(result));
15363 return resultobj;
15364 fail:
15365 return NULL;
15366 }
15367
15368
15369 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15370 PyObject *resultobj = 0;
15371 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15372 double arg2 ;
15373 void *argp1 = 0 ;
15374 int res1 = 0 ;
15375 double val2 ;
15376 int ecode2 = 0 ;
15377 PyObject *swig_obj[2] ;
15378
15379 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15381 if (!SWIG_IsOK(res1)) {
15382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15383 }
15384 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15385 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15386 if (!SWIG_IsOK(ecode2)) {
15387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15388 }
15389 arg2 = static_cast< double >(val2);
15390 if (arg1) (arg1)->saturation = arg2;
15391
15392 resultobj = SWIG_Py_Void();
15393 return resultobj;
15394 fail:
15395 return NULL;
15396 }
15397
15398
15399 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15400 PyObject *resultobj = 0;
15401 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15402 double result;
15403 void *argp1 = 0 ;
15404 int res1 = 0 ;
15405 PyObject *swig_obj[1] ;
15406
15407 if (!args) SWIG_fail;
15408 swig_obj[0] = args;
15409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15410 if (!SWIG_IsOK(res1)) {
15411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15412 }
15413 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15414 result = (double) ((arg1)->saturation);
15415 resultobj = SWIG_From_double(static_cast< double >(result));
15416 return resultobj;
15417 fail:
15418 return NULL;
15419 }
15420
15421
15422 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15423 PyObject *resultobj = 0;
15424 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15425 double arg2 ;
15426 void *argp1 = 0 ;
15427 int res1 = 0 ;
15428 double val2 ;
15429 int ecode2 = 0 ;
15430 PyObject *swig_obj[2] ;
15431
15432 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15434 if (!SWIG_IsOK(res1)) {
15435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15436 }
15437 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15438 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15439 if (!SWIG_IsOK(ecode2)) {
15440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15441 }
15442 arg2 = static_cast< double >(val2);
15443 if (arg1) (arg1)->value = arg2;
15444
15445 resultobj = SWIG_Py_Void();
15446 return resultobj;
15447 fail:
15448 return NULL;
15449 }
15450
15451
15452 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15453 PyObject *resultobj = 0;
15454 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15455 double result;
15456 void *argp1 = 0 ;
15457 int res1 = 0 ;
15458 PyObject *swig_obj[1] ;
15459
15460 if (!args) SWIG_fail;
15461 swig_obj[0] = args;
15462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15463 if (!SWIG_IsOK(res1)) {
15464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15465 }
15466 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15467 result = (double) ((arg1)->value);
15468 resultobj = SWIG_From_double(static_cast< double >(result));
15469 return resultobj;
15470 fail:
15471 return NULL;
15472 }
15473
15474
15475 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15476 PyObject *obj;
15477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15478 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15479 return SWIG_Py_Void();
15480 }
15481
15482 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15483 return SWIG_Python_InitShadowInstance(args);
15484 }
15485
15486 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15487 PyObject *resultobj = 0;
15488 wxString *arg1 = 0 ;
15489 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15490 int arg3 = (int) -1 ;
15491 wxImage *result = 0 ;
15492 bool temp1 = false ;
15493 long val2 ;
15494 int ecode2 = 0 ;
15495 int val3 ;
15496 int ecode3 = 0 ;
15497 PyObject * obj0 = 0 ;
15498 PyObject * obj1 = 0 ;
15499 PyObject * obj2 = 0 ;
15500 char * kwnames[] = {
15501 (char *) "name",(char *) "type",(char *) "index", NULL
15502 };
15503
15504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15505 {
15506 arg1 = wxString_in_helper(obj0);
15507 if (arg1 == NULL) SWIG_fail;
15508 temp1 = true;
15509 }
15510 if (obj1) {
15511 ecode2 = SWIG_AsVal_long(obj1, &val2);
15512 if (!SWIG_IsOK(ecode2)) {
15513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15514 }
15515 arg2 = static_cast< long >(val2);
15516 }
15517 if (obj2) {
15518 ecode3 = SWIG_AsVal_int(obj2, &val3);
15519 if (!SWIG_IsOK(ecode3)) {
15520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15521 }
15522 arg3 = static_cast< int >(val3);
15523 }
15524 {
15525 PyThreadState* __tstate = wxPyBeginAllowThreads();
15526 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15527 wxPyEndAllowThreads(__tstate);
15528 if (PyErr_Occurred()) SWIG_fail;
15529 }
15530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15531 {
15532 if (temp1)
15533 delete arg1;
15534 }
15535 return resultobj;
15536 fail:
15537 {
15538 if (temp1)
15539 delete arg1;
15540 }
15541 return NULL;
15542 }
15543
15544
15545 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15546 PyObject *resultobj = 0;
15547 wxImage *arg1 = (wxImage *) 0 ;
15548 void *argp1 = 0 ;
15549 int res1 = 0 ;
15550 PyObject *swig_obj[1] ;
15551
15552 if (!args) SWIG_fail;
15553 swig_obj[0] = args;
15554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15555 if (!SWIG_IsOK(res1)) {
15556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15557 }
15558 arg1 = reinterpret_cast< wxImage * >(argp1);
15559 {
15560 PyThreadState* __tstate = wxPyBeginAllowThreads();
15561 delete arg1;
15562
15563 wxPyEndAllowThreads(__tstate);
15564 if (PyErr_Occurred()) SWIG_fail;
15565 }
15566 resultobj = SWIG_Py_Void();
15567 return resultobj;
15568 fail:
15569 return NULL;
15570 }
15571
15572
15573 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15574 PyObject *resultobj = 0;
15575 wxString *arg1 = 0 ;
15576 wxString *arg2 = 0 ;
15577 int arg3 = (int) -1 ;
15578 wxImage *result = 0 ;
15579 bool temp1 = false ;
15580 bool temp2 = false ;
15581 int val3 ;
15582 int ecode3 = 0 ;
15583 PyObject * obj0 = 0 ;
15584 PyObject * obj1 = 0 ;
15585 PyObject * obj2 = 0 ;
15586 char * kwnames[] = {
15587 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15588 };
15589
15590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15591 {
15592 arg1 = wxString_in_helper(obj0);
15593 if (arg1 == NULL) SWIG_fail;
15594 temp1 = true;
15595 }
15596 {
15597 arg2 = wxString_in_helper(obj1);
15598 if (arg2 == NULL) SWIG_fail;
15599 temp2 = true;
15600 }
15601 if (obj2) {
15602 ecode3 = SWIG_AsVal_int(obj2, &val3);
15603 if (!SWIG_IsOK(ecode3)) {
15604 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15605 }
15606 arg3 = static_cast< int >(val3);
15607 }
15608 {
15609 PyThreadState* __tstate = wxPyBeginAllowThreads();
15610 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15611 wxPyEndAllowThreads(__tstate);
15612 if (PyErr_Occurred()) SWIG_fail;
15613 }
15614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15615 {
15616 if (temp1)
15617 delete arg1;
15618 }
15619 {
15620 if (temp2)
15621 delete arg2;
15622 }
15623 return resultobj;
15624 fail:
15625 {
15626 if (temp1)
15627 delete arg1;
15628 }
15629 {
15630 if (temp2)
15631 delete arg2;
15632 }
15633 return NULL;
15634 }
15635
15636
15637 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15638 PyObject *resultobj = 0;
15639 wxInputStream *arg1 = 0 ;
15640 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15641 int arg3 = (int) -1 ;
15642 wxImage *result = 0 ;
15643 wxPyInputStream *temp1 ;
15644 bool created1 ;
15645 long val2 ;
15646 int ecode2 = 0 ;
15647 int val3 ;
15648 int ecode3 = 0 ;
15649 PyObject * obj0 = 0 ;
15650 PyObject * obj1 = 0 ;
15651 PyObject * obj2 = 0 ;
15652 char * kwnames[] = {
15653 (char *) "stream",(char *) "type",(char *) "index", NULL
15654 };
15655
15656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15657 {
15658 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15659 arg1 = temp1->m_wxis;
15660 created1 = false;
15661 } else {
15662 PyErr_Clear(); // clear the failure of the wxPyConvert above
15663 arg1 = wxPyCBInputStream_create(obj0, false);
15664 if (arg1 == NULL) {
15665 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15666 SWIG_fail;
15667 }
15668 created1 = true;
15669 }
15670 }
15671 if (obj1) {
15672 ecode2 = SWIG_AsVal_long(obj1, &val2);
15673 if (!SWIG_IsOK(ecode2)) {
15674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15675 }
15676 arg2 = static_cast< long >(val2);
15677 }
15678 if (obj2) {
15679 ecode3 = SWIG_AsVal_int(obj2, &val3);
15680 if (!SWIG_IsOK(ecode3)) {
15681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15682 }
15683 arg3 = static_cast< int >(val3);
15684 }
15685 {
15686 PyThreadState* __tstate = wxPyBeginAllowThreads();
15687 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15688 wxPyEndAllowThreads(__tstate);
15689 if (PyErr_Occurred()) SWIG_fail;
15690 }
15691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15692 {
15693 if (created1) delete arg1;
15694 }
15695 return resultobj;
15696 fail:
15697 {
15698 if (created1) delete arg1;
15699 }
15700 return NULL;
15701 }
15702
15703
15704 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15705 PyObject *resultobj = 0;
15706 wxInputStream *arg1 = 0 ;
15707 wxString *arg2 = 0 ;
15708 int arg3 = (int) -1 ;
15709 wxImage *result = 0 ;
15710 wxPyInputStream *temp1 ;
15711 bool created1 ;
15712 bool temp2 = false ;
15713 int val3 ;
15714 int ecode3 = 0 ;
15715 PyObject * obj0 = 0 ;
15716 PyObject * obj1 = 0 ;
15717 PyObject * obj2 = 0 ;
15718 char * kwnames[] = {
15719 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15720 };
15721
15722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15723 {
15724 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15725 arg1 = temp1->m_wxis;
15726 created1 = false;
15727 } else {
15728 PyErr_Clear(); // clear the failure of the wxPyConvert above
15729 arg1 = wxPyCBInputStream_create(obj0, false);
15730 if (arg1 == NULL) {
15731 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15732 SWIG_fail;
15733 }
15734 created1 = true;
15735 }
15736 }
15737 {
15738 arg2 = wxString_in_helper(obj1);
15739 if (arg2 == NULL) SWIG_fail;
15740 temp2 = true;
15741 }
15742 if (obj2) {
15743 ecode3 = SWIG_AsVal_int(obj2, &val3);
15744 if (!SWIG_IsOK(ecode3)) {
15745 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15746 }
15747 arg3 = static_cast< int >(val3);
15748 }
15749 {
15750 PyThreadState* __tstate = wxPyBeginAllowThreads();
15751 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15752 wxPyEndAllowThreads(__tstate);
15753 if (PyErr_Occurred()) SWIG_fail;
15754 }
15755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15756 {
15757 if (created1) delete arg1;
15758 }
15759 {
15760 if (temp2)
15761 delete arg2;
15762 }
15763 return resultobj;
15764 fail:
15765 {
15766 if (created1) delete arg1;
15767 }
15768 {
15769 if (temp2)
15770 delete arg2;
15771 }
15772 return NULL;
15773 }
15774
15775
15776 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15777 PyObject *resultobj = 0;
15778 int arg1 = (int) 0 ;
15779 int arg2 = (int) 0 ;
15780 bool arg3 = (bool) true ;
15781 wxImage *result = 0 ;
15782 int val1 ;
15783 int ecode1 = 0 ;
15784 int val2 ;
15785 int ecode2 = 0 ;
15786 bool val3 ;
15787 int ecode3 = 0 ;
15788 PyObject * obj0 = 0 ;
15789 PyObject * obj1 = 0 ;
15790 PyObject * obj2 = 0 ;
15791 char * kwnames[] = {
15792 (char *) "width",(char *) "height",(char *) "clear", NULL
15793 };
15794
15795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15796 if (obj0) {
15797 ecode1 = SWIG_AsVal_int(obj0, &val1);
15798 if (!SWIG_IsOK(ecode1)) {
15799 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15800 }
15801 arg1 = static_cast< int >(val1);
15802 }
15803 if (obj1) {
15804 ecode2 = SWIG_AsVal_int(obj1, &val2);
15805 if (!SWIG_IsOK(ecode2)) {
15806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15807 }
15808 arg2 = static_cast< int >(val2);
15809 }
15810 if (obj2) {
15811 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15812 if (!SWIG_IsOK(ecode3)) {
15813 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15814 }
15815 arg3 = static_cast< bool >(val3);
15816 }
15817 {
15818 PyThreadState* __tstate = wxPyBeginAllowThreads();
15819 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15820 wxPyEndAllowThreads(__tstate);
15821 if (PyErr_Occurred()) SWIG_fail;
15822 }
15823 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15824 return resultobj;
15825 fail:
15826 return NULL;
15827 }
15828
15829
15830 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15831 PyObject *resultobj = 0;
15832 wxBitmap *arg1 = 0 ;
15833 wxImage *result = 0 ;
15834 void *argp1 = 0 ;
15835 int res1 = 0 ;
15836 PyObject * obj0 = 0 ;
15837 char * kwnames[] = {
15838 (char *) "bitmap", NULL
15839 };
15840
15841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15842 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15843 if (!SWIG_IsOK(res1)) {
15844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15845 }
15846 if (!argp1) {
15847 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15848 }
15849 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15850 {
15851 if (!wxPyCheckForApp()) SWIG_fail;
15852 PyThreadState* __tstate = wxPyBeginAllowThreads();
15853 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15854 wxPyEndAllowThreads(__tstate);
15855 if (PyErr_Occurred()) SWIG_fail;
15856 }
15857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15858 return resultobj;
15859 fail:
15860 return NULL;
15861 }
15862
15863
15864 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15865 PyObject *resultobj = 0;
15866 int arg1 ;
15867 int arg2 ;
15868 buffer arg3 ;
15869 int arg4 ;
15870 wxImage *result = 0 ;
15871 int val1 ;
15872 int ecode1 = 0 ;
15873 int val2 ;
15874 int ecode2 = 0 ;
15875 Py_ssize_t temp3 ;
15876 PyObject * obj0 = 0 ;
15877 PyObject * obj1 = 0 ;
15878 PyObject * obj2 = 0 ;
15879 char * kwnames[] = {
15880 (char *) "width",(char *) "height",(char *) "data", NULL
15881 };
15882
15883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15884 ecode1 = SWIG_AsVal_int(obj0, &val1);
15885 if (!SWIG_IsOK(ecode1)) {
15886 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15887 }
15888 arg1 = static_cast< int >(val1);
15889 ecode2 = SWIG_AsVal_int(obj1, &val2);
15890 if (!SWIG_IsOK(ecode2)) {
15891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15892 }
15893 arg2 = static_cast< int >(val2);
15894 {
15895 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15896 arg4 = (int)temp3;
15897 }
15898 {
15899 PyThreadState* __tstate = wxPyBeginAllowThreads();
15900 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
15901 wxPyEndAllowThreads(__tstate);
15902 if (PyErr_Occurred()) SWIG_fail;
15903 }
15904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15905 return resultobj;
15906 fail:
15907 return NULL;
15908 }
15909
15910
15911 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15912 PyObject *resultobj = 0;
15913 int arg1 ;
15914 int arg2 ;
15915 buffer arg3 ;
15916 int arg4 ;
15917 buffer arg5 ;
15918 int arg6 ;
15919 wxImage *result = 0 ;
15920 int val1 ;
15921 int ecode1 = 0 ;
15922 int val2 ;
15923 int ecode2 = 0 ;
15924 Py_ssize_t temp3 ;
15925 Py_ssize_t temp5 ;
15926 PyObject * obj0 = 0 ;
15927 PyObject * obj1 = 0 ;
15928 PyObject * obj2 = 0 ;
15929 PyObject * obj3 = 0 ;
15930 char * kwnames[] = {
15931 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
15932 };
15933
15934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15935 ecode1 = SWIG_AsVal_int(obj0, &val1);
15936 if (!SWIG_IsOK(ecode1)) {
15937 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
15938 }
15939 arg1 = static_cast< int >(val1);
15940 ecode2 = SWIG_AsVal_int(obj1, &val2);
15941 if (!SWIG_IsOK(ecode2)) {
15942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
15943 }
15944 arg2 = static_cast< int >(val2);
15945 {
15946 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15947 arg4 = (int)temp3;
15948 }
15949 {
15950 if (obj3 != Py_None) {
15951 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
15952 arg6 = (int)temp5;
15953 }
15954 }
15955 {
15956 PyThreadState* __tstate = wxPyBeginAllowThreads();
15957 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
15958 wxPyEndAllowThreads(__tstate);
15959 if (PyErr_Occurred()) SWIG_fail;
15960 }
15961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15962 return resultobj;
15963 fail:
15964 return NULL;
15965 }
15966
15967
15968 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15969 PyObject *resultobj = 0;
15970 wxImage *arg1 = (wxImage *) 0 ;
15971 int arg2 ;
15972 int arg3 ;
15973 bool arg4 = (bool) true ;
15974 void *argp1 = 0 ;
15975 int res1 = 0 ;
15976 int val2 ;
15977 int ecode2 = 0 ;
15978 int val3 ;
15979 int ecode3 = 0 ;
15980 bool val4 ;
15981 int ecode4 = 0 ;
15982 PyObject * obj0 = 0 ;
15983 PyObject * obj1 = 0 ;
15984 PyObject * obj2 = 0 ;
15985 PyObject * obj3 = 0 ;
15986 char * kwnames[] = {
15987 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
15988 };
15989
15990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15992 if (!SWIG_IsOK(res1)) {
15993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
15994 }
15995 arg1 = reinterpret_cast< wxImage * >(argp1);
15996 ecode2 = SWIG_AsVal_int(obj1, &val2);
15997 if (!SWIG_IsOK(ecode2)) {
15998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
15999 }
16000 arg2 = static_cast< int >(val2);
16001 ecode3 = SWIG_AsVal_int(obj2, &val3);
16002 if (!SWIG_IsOK(ecode3)) {
16003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
16004 }
16005 arg3 = static_cast< int >(val3);
16006 if (obj3) {
16007 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16008 if (!SWIG_IsOK(ecode4)) {
16009 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
16010 }
16011 arg4 = static_cast< bool >(val4);
16012 }
16013 {
16014 PyThreadState* __tstate = wxPyBeginAllowThreads();
16015 (arg1)->Create(arg2,arg3,arg4);
16016 wxPyEndAllowThreads(__tstate);
16017 if (PyErr_Occurred()) SWIG_fail;
16018 }
16019 resultobj = SWIG_Py_Void();
16020 return resultobj;
16021 fail:
16022 return NULL;
16023 }
16024
16025
16026 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16027 PyObject *resultobj = 0;
16028 wxImage *arg1 = (wxImage *) 0 ;
16029 void *argp1 = 0 ;
16030 int res1 = 0 ;
16031 PyObject *swig_obj[1] ;
16032
16033 if (!args) SWIG_fail;
16034 swig_obj[0] = args;
16035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16036 if (!SWIG_IsOK(res1)) {
16037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16038 }
16039 arg1 = reinterpret_cast< wxImage * >(argp1);
16040 {
16041 PyThreadState* __tstate = wxPyBeginAllowThreads();
16042 (arg1)->Destroy();
16043 wxPyEndAllowThreads(__tstate);
16044 if (PyErr_Occurred()) SWIG_fail;
16045 }
16046 resultobj = SWIG_Py_Void();
16047 return resultobj;
16048 fail:
16049 return NULL;
16050 }
16051
16052
16053 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16054 PyObject *resultobj = 0;
16055 wxImage *arg1 = (wxImage *) 0 ;
16056 int arg2 ;
16057 int arg3 ;
16058 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16059 SwigValueWrapper<wxImage > result;
16060 void *argp1 = 0 ;
16061 int res1 = 0 ;
16062 int val2 ;
16063 int ecode2 = 0 ;
16064 int val3 ;
16065 int ecode3 = 0 ;
16066 int val4 ;
16067 int ecode4 = 0 ;
16068 PyObject * obj0 = 0 ;
16069 PyObject * obj1 = 0 ;
16070 PyObject * obj2 = 0 ;
16071 PyObject * obj3 = 0 ;
16072 char * kwnames[] = {
16073 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16074 };
16075
16076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16078 if (!SWIG_IsOK(res1)) {
16079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16080 }
16081 arg1 = reinterpret_cast< wxImage * >(argp1);
16082 ecode2 = SWIG_AsVal_int(obj1, &val2);
16083 if (!SWIG_IsOK(ecode2)) {
16084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16085 }
16086 arg2 = static_cast< int >(val2);
16087 ecode3 = SWIG_AsVal_int(obj2, &val3);
16088 if (!SWIG_IsOK(ecode3)) {
16089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16090 }
16091 arg3 = static_cast< int >(val3);
16092 if (obj3) {
16093 ecode4 = SWIG_AsVal_int(obj3, &val4);
16094 if (!SWIG_IsOK(ecode4)) {
16095 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16096 }
16097 arg4 = static_cast< int >(val4);
16098 }
16099 {
16100 PyThreadState* __tstate = wxPyBeginAllowThreads();
16101 result = (arg1)->Scale(arg2,arg3,arg4);
16102 wxPyEndAllowThreads(__tstate);
16103 if (PyErr_Occurred()) SWIG_fail;
16104 }
16105 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16106 return resultobj;
16107 fail:
16108 return NULL;
16109 }
16110
16111
16112 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16113 PyObject *resultobj = 0;
16114 wxImage *arg1 = (wxImage *) 0 ;
16115 int arg2 ;
16116 int arg3 ;
16117 SwigValueWrapper<wxImage > result;
16118 void *argp1 = 0 ;
16119 int res1 = 0 ;
16120 int val2 ;
16121 int ecode2 = 0 ;
16122 int val3 ;
16123 int ecode3 = 0 ;
16124 PyObject * obj0 = 0 ;
16125 PyObject * obj1 = 0 ;
16126 PyObject * obj2 = 0 ;
16127 char * kwnames[] = {
16128 (char *) "self",(char *) "width",(char *) "height", NULL
16129 };
16130
16131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16133 if (!SWIG_IsOK(res1)) {
16134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16135 }
16136 arg1 = reinterpret_cast< wxImage * >(argp1);
16137 ecode2 = SWIG_AsVal_int(obj1, &val2);
16138 if (!SWIG_IsOK(ecode2)) {
16139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16140 }
16141 arg2 = static_cast< int >(val2);
16142 ecode3 = SWIG_AsVal_int(obj2, &val3);
16143 if (!SWIG_IsOK(ecode3)) {
16144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16145 }
16146 arg3 = static_cast< int >(val3);
16147 {
16148 PyThreadState* __tstate = wxPyBeginAllowThreads();
16149 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16150 wxPyEndAllowThreads(__tstate);
16151 if (PyErr_Occurred()) SWIG_fail;
16152 }
16153 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16154 return resultobj;
16155 fail:
16156 return NULL;
16157 }
16158
16159
16160 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16161 PyObject *resultobj = 0;
16162 wxImage *arg1 = (wxImage *) 0 ;
16163 int arg2 ;
16164 int arg3 ;
16165 SwigValueWrapper<wxImage > result;
16166 void *argp1 = 0 ;
16167 int res1 = 0 ;
16168 int val2 ;
16169 int ecode2 = 0 ;
16170 int val3 ;
16171 int ecode3 = 0 ;
16172 PyObject * obj0 = 0 ;
16173 PyObject * obj1 = 0 ;
16174 PyObject * obj2 = 0 ;
16175 char * kwnames[] = {
16176 (char *) "self",(char *) "width",(char *) "height", NULL
16177 };
16178
16179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16181 if (!SWIG_IsOK(res1)) {
16182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16183 }
16184 arg1 = reinterpret_cast< wxImage * >(argp1);
16185 ecode2 = SWIG_AsVal_int(obj1, &val2);
16186 if (!SWIG_IsOK(ecode2)) {
16187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16188 }
16189 arg2 = static_cast< int >(val2);
16190 ecode3 = SWIG_AsVal_int(obj2, &val3);
16191 if (!SWIG_IsOK(ecode3)) {
16192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16193 }
16194 arg3 = static_cast< int >(val3);
16195 {
16196 PyThreadState* __tstate = wxPyBeginAllowThreads();
16197 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16198 wxPyEndAllowThreads(__tstate);
16199 if (PyErr_Occurred()) SWIG_fail;
16200 }
16201 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16202 return resultobj;
16203 fail:
16204 return NULL;
16205 }
16206
16207
16208 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16209 PyObject *resultobj = 0;
16210 wxImage *arg1 = (wxImage *) 0 ;
16211 int arg2 ;
16212 SwigValueWrapper<wxImage > result;
16213 void *argp1 = 0 ;
16214 int res1 = 0 ;
16215 int val2 ;
16216 int ecode2 = 0 ;
16217 PyObject * obj0 = 0 ;
16218 PyObject * obj1 = 0 ;
16219 char * kwnames[] = {
16220 (char *) "self",(char *) "radius", NULL
16221 };
16222
16223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16225 if (!SWIG_IsOK(res1)) {
16226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16227 }
16228 arg1 = reinterpret_cast< wxImage * >(argp1);
16229 ecode2 = SWIG_AsVal_int(obj1, &val2);
16230 if (!SWIG_IsOK(ecode2)) {
16231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16232 }
16233 arg2 = static_cast< int >(val2);
16234 {
16235 PyThreadState* __tstate = wxPyBeginAllowThreads();
16236 result = (arg1)->Blur(arg2);
16237 wxPyEndAllowThreads(__tstate);
16238 if (PyErr_Occurred()) SWIG_fail;
16239 }
16240 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16241 return resultobj;
16242 fail:
16243 return NULL;
16244 }
16245
16246
16247 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16248 PyObject *resultobj = 0;
16249 wxImage *arg1 = (wxImage *) 0 ;
16250 int arg2 ;
16251 SwigValueWrapper<wxImage > result;
16252 void *argp1 = 0 ;
16253 int res1 = 0 ;
16254 int val2 ;
16255 int ecode2 = 0 ;
16256 PyObject * obj0 = 0 ;
16257 PyObject * obj1 = 0 ;
16258 char * kwnames[] = {
16259 (char *) "self",(char *) "radius", NULL
16260 };
16261
16262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16264 if (!SWIG_IsOK(res1)) {
16265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16266 }
16267 arg1 = reinterpret_cast< wxImage * >(argp1);
16268 ecode2 = SWIG_AsVal_int(obj1, &val2);
16269 if (!SWIG_IsOK(ecode2)) {
16270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16271 }
16272 arg2 = static_cast< int >(val2);
16273 {
16274 PyThreadState* __tstate = wxPyBeginAllowThreads();
16275 result = (arg1)->BlurHorizontal(arg2);
16276 wxPyEndAllowThreads(__tstate);
16277 if (PyErr_Occurred()) SWIG_fail;
16278 }
16279 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16280 return resultobj;
16281 fail:
16282 return NULL;
16283 }
16284
16285
16286 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16287 PyObject *resultobj = 0;
16288 wxImage *arg1 = (wxImage *) 0 ;
16289 int arg2 ;
16290 SwigValueWrapper<wxImage > result;
16291 void *argp1 = 0 ;
16292 int res1 = 0 ;
16293 int val2 ;
16294 int ecode2 = 0 ;
16295 PyObject * obj0 = 0 ;
16296 PyObject * obj1 = 0 ;
16297 char * kwnames[] = {
16298 (char *) "self",(char *) "radius", NULL
16299 };
16300
16301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16303 if (!SWIG_IsOK(res1)) {
16304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16305 }
16306 arg1 = reinterpret_cast< wxImage * >(argp1);
16307 ecode2 = SWIG_AsVal_int(obj1, &val2);
16308 if (!SWIG_IsOK(ecode2)) {
16309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16310 }
16311 arg2 = static_cast< int >(val2);
16312 {
16313 PyThreadState* __tstate = wxPyBeginAllowThreads();
16314 result = (arg1)->BlurVertical(arg2);
16315 wxPyEndAllowThreads(__tstate);
16316 if (PyErr_Occurred()) SWIG_fail;
16317 }
16318 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16319 return resultobj;
16320 fail:
16321 return NULL;
16322 }
16323
16324
16325 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16326 PyObject *resultobj = 0;
16327 wxImage *arg1 = (wxImage *) 0 ;
16328 int arg2 ;
16329 int arg3 ;
16330 SwigValueWrapper<wxImage > result;
16331 void *argp1 = 0 ;
16332 int res1 = 0 ;
16333 int val2 ;
16334 int ecode2 = 0 ;
16335 int val3 ;
16336 int ecode3 = 0 ;
16337 PyObject * obj0 = 0 ;
16338 PyObject * obj1 = 0 ;
16339 PyObject * obj2 = 0 ;
16340 char * kwnames[] = {
16341 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16342 };
16343
16344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16346 if (!SWIG_IsOK(res1)) {
16347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16348 }
16349 arg1 = reinterpret_cast< wxImage * >(argp1);
16350 ecode2 = SWIG_AsVal_int(obj1, &val2);
16351 if (!SWIG_IsOK(ecode2)) {
16352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16353 }
16354 arg2 = static_cast< int >(val2);
16355 ecode3 = SWIG_AsVal_int(obj2, &val3);
16356 if (!SWIG_IsOK(ecode3)) {
16357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16358 }
16359 arg3 = static_cast< int >(val3);
16360 {
16361 PyThreadState* __tstate = wxPyBeginAllowThreads();
16362 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16363 wxPyEndAllowThreads(__tstate);
16364 if (PyErr_Occurred()) SWIG_fail;
16365 }
16366 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16367 return resultobj;
16368 fail:
16369 return NULL;
16370 }
16371
16372
16373 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16374 PyObject *resultobj = 0;
16375 wxImage *arg1 = (wxImage *) 0 ;
16376 int arg2 ;
16377 int arg3 ;
16378 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16379 wxImage *result = 0 ;
16380 void *argp1 = 0 ;
16381 int res1 = 0 ;
16382 int val2 ;
16383 int ecode2 = 0 ;
16384 int val3 ;
16385 int ecode3 = 0 ;
16386 int val4 ;
16387 int ecode4 = 0 ;
16388 PyObject * obj0 = 0 ;
16389 PyObject * obj1 = 0 ;
16390 PyObject * obj2 = 0 ;
16391 PyObject * obj3 = 0 ;
16392 char * kwnames[] = {
16393 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16394 };
16395
16396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16398 if (!SWIG_IsOK(res1)) {
16399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16400 }
16401 arg1 = reinterpret_cast< wxImage * >(argp1);
16402 ecode2 = SWIG_AsVal_int(obj1, &val2);
16403 if (!SWIG_IsOK(ecode2)) {
16404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16405 }
16406 arg2 = static_cast< int >(val2);
16407 ecode3 = SWIG_AsVal_int(obj2, &val3);
16408 if (!SWIG_IsOK(ecode3)) {
16409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16410 }
16411 arg3 = static_cast< int >(val3);
16412 if (obj3) {
16413 ecode4 = SWIG_AsVal_int(obj3, &val4);
16414 if (!SWIG_IsOK(ecode4)) {
16415 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16416 }
16417 arg4 = static_cast< int >(val4);
16418 }
16419 {
16420 PyThreadState* __tstate = wxPyBeginAllowThreads();
16421 {
16422 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
16423 result = (wxImage *) &_result_ref;
16424 }
16425 wxPyEndAllowThreads(__tstate);
16426 if (PyErr_Occurred()) SWIG_fail;
16427 }
16428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16429 return resultobj;
16430 fail:
16431 return NULL;
16432 }
16433
16434
16435 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16436 PyObject *resultobj = 0;
16437 wxImage *arg1 = (wxImage *) 0 ;
16438 wxSize *arg2 = 0 ;
16439 wxPoint *arg3 = 0 ;
16440 int arg4 = (int) -1 ;
16441 int arg5 = (int) -1 ;
16442 int arg6 = (int) -1 ;
16443 wxImage *result = 0 ;
16444 void *argp1 = 0 ;
16445 int res1 = 0 ;
16446 wxSize temp2 ;
16447 wxPoint temp3 ;
16448 int val4 ;
16449 int ecode4 = 0 ;
16450 int val5 ;
16451 int ecode5 = 0 ;
16452 int val6 ;
16453 int ecode6 = 0 ;
16454 PyObject * obj0 = 0 ;
16455 PyObject * obj1 = 0 ;
16456 PyObject * obj2 = 0 ;
16457 PyObject * obj3 = 0 ;
16458 PyObject * obj4 = 0 ;
16459 PyObject * obj5 = 0 ;
16460 char * kwnames[] = {
16461 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16462 };
16463
16464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16466 if (!SWIG_IsOK(res1)) {
16467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16468 }
16469 arg1 = reinterpret_cast< wxImage * >(argp1);
16470 {
16471 arg2 = &temp2;
16472 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16473 }
16474 {
16475 arg3 = &temp3;
16476 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16477 }
16478 if (obj3) {
16479 ecode4 = SWIG_AsVal_int(obj3, &val4);
16480 if (!SWIG_IsOK(ecode4)) {
16481 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16482 }
16483 arg4 = static_cast< int >(val4);
16484 }
16485 if (obj4) {
16486 ecode5 = SWIG_AsVal_int(obj4, &val5);
16487 if (!SWIG_IsOK(ecode5)) {
16488 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16489 }
16490 arg5 = static_cast< int >(val5);
16491 }
16492 if (obj5) {
16493 ecode6 = SWIG_AsVal_int(obj5, &val6);
16494 if (!SWIG_IsOK(ecode6)) {
16495 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16496 }
16497 arg6 = static_cast< int >(val6);
16498 }
16499 {
16500 PyThreadState* __tstate = wxPyBeginAllowThreads();
16501 {
16502 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16503 result = (wxImage *) &_result_ref;
16504 }
16505 wxPyEndAllowThreads(__tstate);
16506 if (PyErr_Occurred()) SWIG_fail;
16507 }
16508 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16509 return resultobj;
16510 fail:
16511 return NULL;
16512 }
16513
16514
16515 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16516 PyObject *resultobj = 0;
16517 wxImage *arg1 = (wxImage *) 0 ;
16518 int arg2 ;
16519 int arg3 ;
16520 byte arg4 ;
16521 byte arg5 ;
16522 byte arg6 ;
16523 void *argp1 = 0 ;
16524 int res1 = 0 ;
16525 int val2 ;
16526 int ecode2 = 0 ;
16527 int val3 ;
16528 int ecode3 = 0 ;
16529 unsigned char val4 ;
16530 int ecode4 = 0 ;
16531 unsigned char val5 ;
16532 int ecode5 = 0 ;
16533 unsigned char val6 ;
16534 int ecode6 = 0 ;
16535 PyObject * obj0 = 0 ;
16536 PyObject * obj1 = 0 ;
16537 PyObject * obj2 = 0 ;
16538 PyObject * obj3 = 0 ;
16539 PyObject * obj4 = 0 ;
16540 PyObject * obj5 = 0 ;
16541 char * kwnames[] = {
16542 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16543 };
16544
16545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16547 if (!SWIG_IsOK(res1)) {
16548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16549 }
16550 arg1 = reinterpret_cast< wxImage * >(argp1);
16551 ecode2 = SWIG_AsVal_int(obj1, &val2);
16552 if (!SWIG_IsOK(ecode2)) {
16553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16554 }
16555 arg2 = static_cast< int >(val2);
16556 ecode3 = SWIG_AsVal_int(obj2, &val3);
16557 if (!SWIG_IsOK(ecode3)) {
16558 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16559 }
16560 arg3 = static_cast< int >(val3);
16561 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16562 if (!SWIG_IsOK(ecode4)) {
16563 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16564 }
16565 arg4 = static_cast< byte >(val4);
16566 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16567 if (!SWIG_IsOK(ecode5)) {
16568 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16569 }
16570 arg5 = static_cast< byte >(val5);
16571 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16572 if (!SWIG_IsOK(ecode6)) {
16573 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16574 }
16575 arg6 = static_cast< byte >(val6);
16576 {
16577 PyThreadState* __tstate = wxPyBeginAllowThreads();
16578 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16579 wxPyEndAllowThreads(__tstate);
16580 if (PyErr_Occurred()) SWIG_fail;
16581 }
16582 resultobj = SWIG_Py_Void();
16583 return resultobj;
16584 fail:
16585 return NULL;
16586 }
16587
16588
16589 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16590 PyObject *resultobj = 0;
16591 wxImage *arg1 = (wxImage *) 0 ;
16592 wxRect *arg2 = 0 ;
16593 byte arg3 ;
16594 byte arg4 ;
16595 byte arg5 ;
16596 void *argp1 = 0 ;
16597 int res1 = 0 ;
16598 wxRect temp2 ;
16599 unsigned char val3 ;
16600 int ecode3 = 0 ;
16601 unsigned char val4 ;
16602 int ecode4 = 0 ;
16603 unsigned char val5 ;
16604 int ecode5 = 0 ;
16605 PyObject * obj0 = 0 ;
16606 PyObject * obj1 = 0 ;
16607 PyObject * obj2 = 0 ;
16608 PyObject * obj3 = 0 ;
16609 PyObject * obj4 = 0 ;
16610 char * kwnames[] = {
16611 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16612 };
16613
16614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16618 }
16619 arg1 = reinterpret_cast< wxImage * >(argp1);
16620 {
16621 arg2 = &temp2;
16622 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16623 }
16624 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16625 if (!SWIG_IsOK(ecode3)) {
16626 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16627 }
16628 arg3 = static_cast< byte >(val3);
16629 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16630 if (!SWIG_IsOK(ecode4)) {
16631 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16632 }
16633 arg4 = static_cast< byte >(val4);
16634 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16635 if (!SWIG_IsOK(ecode5)) {
16636 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16637 }
16638 arg5 = static_cast< byte >(val5);
16639 {
16640 PyThreadState* __tstate = wxPyBeginAllowThreads();
16641 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16642 wxPyEndAllowThreads(__tstate);
16643 if (PyErr_Occurred()) SWIG_fail;
16644 }
16645 resultobj = SWIG_Py_Void();
16646 return resultobj;
16647 fail:
16648 return NULL;
16649 }
16650
16651
16652 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16653 PyObject *resultobj = 0;
16654 wxImage *arg1 = (wxImage *) 0 ;
16655 int arg2 ;
16656 int arg3 ;
16657 byte result;
16658 void *argp1 = 0 ;
16659 int res1 = 0 ;
16660 int val2 ;
16661 int ecode2 = 0 ;
16662 int val3 ;
16663 int ecode3 = 0 ;
16664 PyObject * obj0 = 0 ;
16665 PyObject * obj1 = 0 ;
16666 PyObject * obj2 = 0 ;
16667 char * kwnames[] = {
16668 (char *) "self",(char *) "x",(char *) "y", NULL
16669 };
16670
16671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16673 if (!SWIG_IsOK(res1)) {
16674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
16675 }
16676 arg1 = reinterpret_cast< wxImage * >(argp1);
16677 ecode2 = SWIG_AsVal_int(obj1, &val2);
16678 if (!SWIG_IsOK(ecode2)) {
16679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
16680 }
16681 arg2 = static_cast< int >(val2);
16682 ecode3 = SWIG_AsVal_int(obj2, &val3);
16683 if (!SWIG_IsOK(ecode3)) {
16684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
16685 }
16686 arg3 = static_cast< int >(val3);
16687 {
16688 PyThreadState* __tstate = wxPyBeginAllowThreads();
16689 result = (byte)(arg1)->GetRed(arg2,arg3);
16690 wxPyEndAllowThreads(__tstate);
16691 if (PyErr_Occurred()) SWIG_fail;
16692 }
16693 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16694 return resultobj;
16695 fail:
16696 return NULL;
16697 }
16698
16699
16700 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16701 PyObject *resultobj = 0;
16702 wxImage *arg1 = (wxImage *) 0 ;
16703 int arg2 ;
16704 int arg3 ;
16705 byte result;
16706 void *argp1 = 0 ;
16707 int res1 = 0 ;
16708 int val2 ;
16709 int ecode2 = 0 ;
16710 int val3 ;
16711 int ecode3 = 0 ;
16712 PyObject * obj0 = 0 ;
16713 PyObject * obj1 = 0 ;
16714 PyObject * obj2 = 0 ;
16715 char * kwnames[] = {
16716 (char *) "self",(char *) "x",(char *) "y", NULL
16717 };
16718
16719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16721 if (!SWIG_IsOK(res1)) {
16722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16723 }
16724 arg1 = reinterpret_cast< wxImage * >(argp1);
16725 ecode2 = SWIG_AsVal_int(obj1, &val2);
16726 if (!SWIG_IsOK(ecode2)) {
16727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
16728 }
16729 arg2 = static_cast< int >(val2);
16730 ecode3 = SWIG_AsVal_int(obj2, &val3);
16731 if (!SWIG_IsOK(ecode3)) {
16732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
16733 }
16734 arg3 = static_cast< int >(val3);
16735 {
16736 PyThreadState* __tstate = wxPyBeginAllowThreads();
16737 result = (byte)(arg1)->GetGreen(arg2,arg3);
16738 wxPyEndAllowThreads(__tstate);
16739 if (PyErr_Occurred()) SWIG_fail;
16740 }
16741 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16742 return resultobj;
16743 fail:
16744 return NULL;
16745 }
16746
16747
16748 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16749 PyObject *resultobj = 0;
16750 wxImage *arg1 = (wxImage *) 0 ;
16751 int arg2 ;
16752 int arg3 ;
16753 byte result;
16754 void *argp1 = 0 ;
16755 int res1 = 0 ;
16756 int val2 ;
16757 int ecode2 = 0 ;
16758 int val3 ;
16759 int ecode3 = 0 ;
16760 PyObject * obj0 = 0 ;
16761 PyObject * obj1 = 0 ;
16762 PyObject * obj2 = 0 ;
16763 char * kwnames[] = {
16764 (char *) "self",(char *) "x",(char *) "y", NULL
16765 };
16766
16767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16769 if (!SWIG_IsOK(res1)) {
16770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16771 }
16772 arg1 = reinterpret_cast< wxImage * >(argp1);
16773 ecode2 = SWIG_AsVal_int(obj1, &val2);
16774 if (!SWIG_IsOK(ecode2)) {
16775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16776 }
16777 arg2 = static_cast< int >(val2);
16778 ecode3 = SWIG_AsVal_int(obj2, &val3);
16779 if (!SWIG_IsOK(ecode3)) {
16780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16781 }
16782 arg3 = static_cast< int >(val3);
16783 {
16784 PyThreadState* __tstate = wxPyBeginAllowThreads();
16785 result = (byte)(arg1)->GetBlue(arg2,arg3);
16786 wxPyEndAllowThreads(__tstate);
16787 if (PyErr_Occurred()) SWIG_fail;
16788 }
16789 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16790 return resultobj;
16791 fail:
16792 return NULL;
16793 }
16794
16795
16796 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16797 PyObject *resultobj = 0;
16798 wxImage *arg1 = (wxImage *) 0 ;
16799 int arg2 ;
16800 int arg3 ;
16801 byte arg4 ;
16802 void *argp1 = 0 ;
16803 int res1 = 0 ;
16804 int val2 ;
16805 int ecode2 = 0 ;
16806 int val3 ;
16807 int ecode3 = 0 ;
16808 unsigned char val4 ;
16809 int ecode4 = 0 ;
16810 PyObject * obj0 = 0 ;
16811 PyObject * obj1 = 0 ;
16812 PyObject * obj2 = 0 ;
16813 PyObject * obj3 = 0 ;
16814 char * kwnames[] = {
16815 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16816 };
16817
16818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16820 if (!SWIG_IsOK(res1)) {
16821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16822 }
16823 arg1 = reinterpret_cast< wxImage * >(argp1);
16824 ecode2 = SWIG_AsVal_int(obj1, &val2);
16825 if (!SWIG_IsOK(ecode2)) {
16826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16827 }
16828 arg2 = static_cast< int >(val2);
16829 ecode3 = SWIG_AsVal_int(obj2, &val3);
16830 if (!SWIG_IsOK(ecode3)) {
16831 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16832 }
16833 arg3 = static_cast< int >(val3);
16834 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16835 if (!SWIG_IsOK(ecode4)) {
16836 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16837 }
16838 arg4 = static_cast< byte >(val4);
16839 {
16840 PyThreadState* __tstate = wxPyBeginAllowThreads();
16841 (arg1)->SetAlpha(arg2,arg3,arg4);
16842 wxPyEndAllowThreads(__tstate);
16843 if (PyErr_Occurred()) SWIG_fail;
16844 }
16845 resultobj = SWIG_Py_Void();
16846 return resultobj;
16847 fail:
16848 return NULL;
16849 }
16850
16851
16852 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16853 PyObject *resultobj = 0;
16854 wxImage *arg1 = (wxImage *) 0 ;
16855 int arg2 ;
16856 int arg3 ;
16857 byte result;
16858 void *argp1 = 0 ;
16859 int res1 = 0 ;
16860 int val2 ;
16861 int ecode2 = 0 ;
16862 int val3 ;
16863 int ecode3 = 0 ;
16864 PyObject * obj0 = 0 ;
16865 PyObject * obj1 = 0 ;
16866 PyObject * obj2 = 0 ;
16867 char * kwnames[] = {
16868 (char *) "self",(char *) "x",(char *) "y", NULL
16869 };
16870
16871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16873 if (!SWIG_IsOK(res1)) {
16874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16875 }
16876 arg1 = reinterpret_cast< wxImage * >(argp1);
16877 ecode2 = SWIG_AsVal_int(obj1, &val2);
16878 if (!SWIG_IsOK(ecode2)) {
16879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16880 }
16881 arg2 = static_cast< int >(val2);
16882 ecode3 = SWIG_AsVal_int(obj2, &val3);
16883 if (!SWIG_IsOK(ecode3)) {
16884 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16885 }
16886 arg3 = static_cast< int >(val3);
16887 {
16888 PyThreadState* __tstate = wxPyBeginAllowThreads();
16889 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16890 wxPyEndAllowThreads(__tstate);
16891 if (PyErr_Occurred()) SWIG_fail;
16892 }
16893 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16894 return resultobj;
16895 fail:
16896 return NULL;
16897 }
16898
16899
16900 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16901 PyObject *resultobj = 0;
16902 wxImage *arg1 = (wxImage *) 0 ;
16903 bool result;
16904 void *argp1 = 0 ;
16905 int res1 = 0 ;
16906 PyObject *swig_obj[1] ;
16907
16908 if (!args) SWIG_fail;
16909 swig_obj[0] = args;
16910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16911 if (!SWIG_IsOK(res1)) {
16912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16913 }
16914 arg1 = reinterpret_cast< wxImage * >(argp1);
16915 {
16916 PyThreadState* __tstate = wxPyBeginAllowThreads();
16917 result = (bool)(arg1)->HasAlpha();
16918 wxPyEndAllowThreads(__tstate);
16919 if (PyErr_Occurred()) SWIG_fail;
16920 }
16921 {
16922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16923 }
16924 return resultobj;
16925 fail:
16926 return NULL;
16927 }
16928
16929
16930 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16931 PyObject *resultobj = 0;
16932 wxImage *arg1 = (wxImage *) 0 ;
16933 void *argp1 = 0 ;
16934 int res1 = 0 ;
16935 PyObject *swig_obj[1] ;
16936
16937 if (!args) SWIG_fail;
16938 swig_obj[0] = args;
16939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16940 if (!SWIG_IsOK(res1)) {
16941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16942 }
16943 arg1 = reinterpret_cast< wxImage * >(argp1);
16944 {
16945 PyThreadState* __tstate = wxPyBeginAllowThreads();
16946 (arg1)->InitAlpha();
16947 wxPyEndAllowThreads(__tstate);
16948 if (PyErr_Occurred()) SWIG_fail;
16949 }
16950 resultobj = SWIG_Py_Void();
16951 return resultobj;
16952 fail:
16953 return NULL;
16954 }
16955
16956
16957 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16958 PyObject *resultobj = 0;
16959 wxImage *arg1 = (wxImage *) 0 ;
16960 int arg2 ;
16961 int arg3 ;
16962 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
16963 bool result;
16964 void *argp1 = 0 ;
16965 int res1 = 0 ;
16966 int val2 ;
16967 int ecode2 = 0 ;
16968 int val3 ;
16969 int ecode3 = 0 ;
16970 unsigned char val4 ;
16971 int ecode4 = 0 ;
16972 PyObject * obj0 = 0 ;
16973 PyObject * obj1 = 0 ;
16974 PyObject * obj2 = 0 ;
16975 PyObject * obj3 = 0 ;
16976 char * kwnames[] = {
16977 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
16978 };
16979
16980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16982 if (!SWIG_IsOK(res1)) {
16983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
16984 }
16985 arg1 = reinterpret_cast< wxImage * >(argp1);
16986 ecode2 = SWIG_AsVal_int(obj1, &val2);
16987 if (!SWIG_IsOK(ecode2)) {
16988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
16989 }
16990 arg2 = static_cast< int >(val2);
16991 ecode3 = SWIG_AsVal_int(obj2, &val3);
16992 if (!SWIG_IsOK(ecode3)) {
16993 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
16994 }
16995 arg3 = static_cast< int >(val3);
16996 if (obj3) {
16997 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16998 if (!SWIG_IsOK(ecode4)) {
16999 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
17000 }
17001 arg4 = static_cast< byte >(val4);
17002 }
17003 {
17004 PyThreadState* __tstate = wxPyBeginAllowThreads();
17005 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
17006 wxPyEndAllowThreads(__tstate);
17007 if (PyErr_Occurred()) SWIG_fail;
17008 }
17009 {
17010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17011 }
17012 return resultobj;
17013 fail:
17014 return NULL;
17015 }
17016
17017
17018 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17019 PyObject *resultobj = 0;
17020 wxImage *arg1 = (wxImage *) 0 ;
17021 byte *arg2 = (byte *) 0 ;
17022 byte *arg3 = (byte *) 0 ;
17023 byte *arg4 = (byte *) 0 ;
17024 byte arg5 = (byte) 0 ;
17025 byte arg6 = (byte) 0 ;
17026 byte arg7 = (byte) 0 ;
17027 bool result;
17028 void *argp1 = 0 ;
17029 int res1 = 0 ;
17030 byte temp2 ;
17031 int res2 = SWIG_TMPOBJ ;
17032 byte temp3 ;
17033 int res3 = SWIG_TMPOBJ ;
17034 byte temp4 ;
17035 int res4 = SWIG_TMPOBJ ;
17036 unsigned char val5 ;
17037 int ecode5 = 0 ;
17038 unsigned char val6 ;
17039 int ecode6 = 0 ;
17040 unsigned char val7 ;
17041 int ecode7 = 0 ;
17042 PyObject * obj0 = 0 ;
17043 PyObject * obj1 = 0 ;
17044 PyObject * obj2 = 0 ;
17045 PyObject * obj3 = 0 ;
17046 char * kwnames[] = {
17047 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17048 };
17049
17050 arg2 = &temp2;
17051 arg3 = &temp3;
17052 arg4 = &temp4;
17053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17055 if (!SWIG_IsOK(res1)) {
17056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17057 }
17058 arg1 = reinterpret_cast< wxImage * >(argp1);
17059 if (obj1) {
17060 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17061 if (!SWIG_IsOK(ecode5)) {
17062 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17063 }
17064 arg5 = static_cast< byte >(val5);
17065 }
17066 if (obj2) {
17067 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17068 if (!SWIG_IsOK(ecode6)) {
17069 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17070 }
17071 arg6 = static_cast< byte >(val6);
17072 }
17073 if (obj3) {
17074 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17075 if (!SWIG_IsOK(ecode7)) {
17076 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17077 }
17078 arg7 = static_cast< byte >(val7);
17079 }
17080 {
17081 PyThreadState* __tstate = wxPyBeginAllowThreads();
17082 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17083 wxPyEndAllowThreads(__tstate);
17084 if (PyErr_Occurred()) SWIG_fail;
17085 }
17086 {
17087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17088 }
17089 if (SWIG_IsTmpObj(res2)) {
17090 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17091 } else {
17092 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17093 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17094 }
17095 if (SWIG_IsTmpObj(res3)) {
17096 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17097 } else {
17098 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17099 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17100 }
17101 if (SWIG_IsTmpObj(res4)) {
17102 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17103 } else {
17104 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17105 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17106 }
17107 return resultobj;
17108 fail:
17109 return NULL;
17110 }
17111
17112
17113 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17114 PyObject *resultobj = 0;
17115 wxImage *arg1 = (wxImage *) 0 ;
17116 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17117 bool result;
17118 void *argp1 = 0 ;
17119 int res1 = 0 ;
17120 unsigned char val2 ;
17121 int ecode2 = 0 ;
17122 PyObject * obj0 = 0 ;
17123 PyObject * obj1 = 0 ;
17124 char * kwnames[] = {
17125 (char *) "self",(char *) "threshold", NULL
17126 };
17127
17128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17130 if (!SWIG_IsOK(res1)) {
17131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17132 }
17133 arg1 = reinterpret_cast< wxImage * >(argp1);
17134 if (obj1) {
17135 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17136 if (!SWIG_IsOK(ecode2)) {
17137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17138 }
17139 arg2 = static_cast< byte >(val2);
17140 }
17141 {
17142 PyThreadState* __tstate = wxPyBeginAllowThreads();
17143 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17144 wxPyEndAllowThreads(__tstate);
17145 if (PyErr_Occurred()) SWIG_fail;
17146 }
17147 {
17148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17149 }
17150 return resultobj;
17151 fail:
17152 return NULL;
17153 }
17154
17155
17156 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17157 PyObject *resultobj = 0;
17158 wxImage *arg1 = (wxImage *) 0 ;
17159 byte arg2 ;
17160 byte arg3 ;
17161 byte arg4 ;
17162 bool result;
17163 void *argp1 = 0 ;
17164 int res1 = 0 ;
17165 unsigned char val2 ;
17166 int ecode2 = 0 ;
17167 unsigned char val3 ;
17168 int ecode3 = 0 ;
17169 unsigned char val4 ;
17170 int ecode4 = 0 ;
17171 PyObject * obj0 = 0 ;
17172 PyObject * obj1 = 0 ;
17173 PyObject * obj2 = 0 ;
17174 PyObject * obj3 = 0 ;
17175 char * kwnames[] = {
17176 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17177 };
17178
17179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17181 if (!SWIG_IsOK(res1)) {
17182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17183 }
17184 arg1 = reinterpret_cast< wxImage * >(argp1);
17185 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17186 if (!SWIG_IsOK(ecode2)) {
17187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17188 }
17189 arg2 = static_cast< byte >(val2);
17190 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17191 if (!SWIG_IsOK(ecode3)) {
17192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17193 }
17194 arg3 = static_cast< byte >(val3);
17195 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17196 if (!SWIG_IsOK(ecode4)) {
17197 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17198 }
17199 arg4 = static_cast< byte >(val4);
17200 {
17201 PyThreadState* __tstate = wxPyBeginAllowThreads();
17202 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17203 wxPyEndAllowThreads(__tstate);
17204 if (PyErr_Occurred()) SWIG_fail;
17205 }
17206 {
17207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17208 }
17209 return resultobj;
17210 fail:
17211 return NULL;
17212 }
17213
17214
17215 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17216 PyObject *resultobj = 0;
17217 wxImage *arg1 = (wxImage *) 0 ;
17218 wxImage *arg2 = 0 ;
17219 byte arg3 ;
17220 byte arg4 ;
17221 byte arg5 ;
17222 bool result;
17223 void *argp1 = 0 ;
17224 int res1 = 0 ;
17225 void *argp2 = 0 ;
17226 int res2 = 0 ;
17227 unsigned char val3 ;
17228 int ecode3 = 0 ;
17229 unsigned char val4 ;
17230 int ecode4 = 0 ;
17231 unsigned char val5 ;
17232 int ecode5 = 0 ;
17233 PyObject * obj0 = 0 ;
17234 PyObject * obj1 = 0 ;
17235 PyObject * obj2 = 0 ;
17236 PyObject * obj3 = 0 ;
17237 PyObject * obj4 = 0 ;
17238 char * kwnames[] = {
17239 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17240 };
17241
17242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17244 if (!SWIG_IsOK(res1)) {
17245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17246 }
17247 arg1 = reinterpret_cast< wxImage * >(argp1);
17248 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17249 if (!SWIG_IsOK(res2)) {
17250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17251 }
17252 if (!argp2) {
17253 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17254 }
17255 arg2 = reinterpret_cast< wxImage * >(argp2);
17256 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17257 if (!SWIG_IsOK(ecode3)) {
17258 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17259 }
17260 arg3 = static_cast< byte >(val3);
17261 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17262 if (!SWIG_IsOK(ecode4)) {
17263 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17264 }
17265 arg4 = static_cast< byte >(val4);
17266 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17267 if (!SWIG_IsOK(ecode5)) {
17268 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17269 }
17270 arg5 = static_cast< byte >(val5);
17271 {
17272 PyThreadState* __tstate = wxPyBeginAllowThreads();
17273 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17274 wxPyEndAllowThreads(__tstate);
17275 if (PyErr_Occurred()) SWIG_fail;
17276 }
17277 {
17278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17279 }
17280 return resultobj;
17281 fail:
17282 return NULL;
17283 }
17284
17285
17286 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17287 PyObject *resultobj = 0;
17288 wxString *arg1 = 0 ;
17289 bool result;
17290 bool temp1 = false ;
17291 PyObject * obj0 = 0 ;
17292 char * kwnames[] = {
17293 (char *) "filename", NULL
17294 };
17295
17296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17297 {
17298 arg1 = wxString_in_helper(obj0);
17299 if (arg1 == NULL) SWIG_fail;
17300 temp1 = true;
17301 }
17302 {
17303 PyThreadState* __tstate = wxPyBeginAllowThreads();
17304 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17305 wxPyEndAllowThreads(__tstate);
17306 if (PyErr_Occurred()) SWIG_fail;
17307 }
17308 {
17309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17310 }
17311 {
17312 if (temp1)
17313 delete arg1;
17314 }
17315 return resultobj;
17316 fail:
17317 {
17318 if (temp1)
17319 delete arg1;
17320 }
17321 return NULL;
17322 }
17323
17324
17325 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17326 PyObject *resultobj = 0;
17327 wxString *arg1 = 0 ;
17328 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17329 int result;
17330 bool temp1 = false ;
17331 long val2 ;
17332 int ecode2 = 0 ;
17333 PyObject * obj0 = 0 ;
17334 PyObject * obj1 = 0 ;
17335 char * kwnames[] = {
17336 (char *) "filename",(char *) "type", NULL
17337 };
17338
17339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17340 {
17341 arg1 = wxString_in_helper(obj0);
17342 if (arg1 == NULL) SWIG_fail;
17343 temp1 = true;
17344 }
17345 if (obj1) {
17346 ecode2 = SWIG_AsVal_long(obj1, &val2);
17347 if (!SWIG_IsOK(ecode2)) {
17348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17349 }
17350 arg2 = static_cast< long >(val2);
17351 }
17352 {
17353 PyThreadState* __tstate = wxPyBeginAllowThreads();
17354 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17355 wxPyEndAllowThreads(__tstate);
17356 if (PyErr_Occurred()) SWIG_fail;
17357 }
17358 resultobj = SWIG_From_int(static_cast< int >(result));
17359 {
17360 if (temp1)
17361 delete arg1;
17362 }
17363 return resultobj;
17364 fail:
17365 {
17366 if (temp1)
17367 delete arg1;
17368 }
17369 return NULL;
17370 }
17371
17372
17373 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17374 PyObject *resultobj = 0;
17375 wxImage *arg1 = (wxImage *) 0 ;
17376 wxString *arg2 = 0 ;
17377 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17378 int arg4 = (int) -1 ;
17379 bool result;
17380 void *argp1 = 0 ;
17381 int res1 = 0 ;
17382 bool temp2 = false ;
17383 long val3 ;
17384 int ecode3 = 0 ;
17385 int val4 ;
17386 int ecode4 = 0 ;
17387 PyObject * obj0 = 0 ;
17388 PyObject * obj1 = 0 ;
17389 PyObject * obj2 = 0 ;
17390 PyObject * obj3 = 0 ;
17391 char * kwnames[] = {
17392 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17393 };
17394
17395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17397 if (!SWIG_IsOK(res1)) {
17398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17399 }
17400 arg1 = reinterpret_cast< wxImage * >(argp1);
17401 {
17402 arg2 = wxString_in_helper(obj1);
17403 if (arg2 == NULL) SWIG_fail;
17404 temp2 = true;
17405 }
17406 if (obj2) {
17407 ecode3 = SWIG_AsVal_long(obj2, &val3);
17408 if (!SWIG_IsOK(ecode3)) {
17409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17410 }
17411 arg3 = static_cast< long >(val3);
17412 }
17413 if (obj3) {
17414 ecode4 = SWIG_AsVal_int(obj3, &val4);
17415 if (!SWIG_IsOK(ecode4)) {
17416 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17417 }
17418 arg4 = static_cast< int >(val4);
17419 }
17420 {
17421 PyThreadState* __tstate = wxPyBeginAllowThreads();
17422 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17423 wxPyEndAllowThreads(__tstate);
17424 if (PyErr_Occurred()) SWIG_fail;
17425 }
17426 {
17427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17428 }
17429 {
17430 if (temp2)
17431 delete arg2;
17432 }
17433 return resultobj;
17434 fail:
17435 {
17436 if (temp2)
17437 delete arg2;
17438 }
17439 return NULL;
17440 }
17441
17442
17443 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17444 PyObject *resultobj = 0;
17445 wxImage *arg1 = (wxImage *) 0 ;
17446 wxString *arg2 = 0 ;
17447 wxString *arg3 = 0 ;
17448 int arg4 = (int) -1 ;
17449 bool result;
17450 void *argp1 = 0 ;
17451 int res1 = 0 ;
17452 bool temp2 = false ;
17453 bool temp3 = false ;
17454 int val4 ;
17455 int ecode4 = 0 ;
17456 PyObject * obj0 = 0 ;
17457 PyObject * obj1 = 0 ;
17458 PyObject * obj2 = 0 ;
17459 PyObject * obj3 = 0 ;
17460 char * kwnames[] = {
17461 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17462 };
17463
17464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17466 if (!SWIG_IsOK(res1)) {
17467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17468 }
17469 arg1 = reinterpret_cast< wxImage * >(argp1);
17470 {
17471 arg2 = wxString_in_helper(obj1);
17472 if (arg2 == NULL) SWIG_fail;
17473 temp2 = true;
17474 }
17475 {
17476 arg3 = wxString_in_helper(obj2);
17477 if (arg3 == NULL) SWIG_fail;
17478 temp3 = true;
17479 }
17480 if (obj3) {
17481 ecode4 = SWIG_AsVal_int(obj3, &val4);
17482 if (!SWIG_IsOK(ecode4)) {
17483 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17484 }
17485 arg4 = static_cast< int >(val4);
17486 }
17487 {
17488 PyThreadState* __tstate = wxPyBeginAllowThreads();
17489 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17490 wxPyEndAllowThreads(__tstate);
17491 if (PyErr_Occurred()) SWIG_fail;
17492 }
17493 {
17494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17495 }
17496 {
17497 if (temp2)
17498 delete arg2;
17499 }
17500 {
17501 if (temp3)
17502 delete arg3;
17503 }
17504 return resultobj;
17505 fail:
17506 {
17507 if (temp2)
17508 delete arg2;
17509 }
17510 {
17511 if (temp3)
17512 delete arg3;
17513 }
17514 return NULL;
17515 }
17516
17517
17518 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17519 PyObject *resultobj = 0;
17520 wxImage *arg1 = (wxImage *) 0 ;
17521 wxString *arg2 = 0 ;
17522 int arg3 ;
17523 bool result;
17524 void *argp1 = 0 ;
17525 int res1 = 0 ;
17526 bool temp2 = false ;
17527 int val3 ;
17528 int ecode3 = 0 ;
17529 PyObject * obj0 = 0 ;
17530 PyObject * obj1 = 0 ;
17531 PyObject * obj2 = 0 ;
17532 char * kwnames[] = {
17533 (char *) "self",(char *) "name",(char *) "type", NULL
17534 };
17535
17536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17538 if (!SWIG_IsOK(res1)) {
17539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17540 }
17541 arg1 = reinterpret_cast< wxImage * >(argp1);
17542 {
17543 arg2 = wxString_in_helper(obj1);
17544 if (arg2 == NULL) SWIG_fail;
17545 temp2 = true;
17546 }
17547 ecode3 = SWIG_AsVal_int(obj2, &val3);
17548 if (!SWIG_IsOK(ecode3)) {
17549 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17550 }
17551 arg3 = static_cast< int >(val3);
17552 {
17553 PyThreadState* __tstate = wxPyBeginAllowThreads();
17554 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17555 wxPyEndAllowThreads(__tstate);
17556 if (PyErr_Occurred()) SWIG_fail;
17557 }
17558 {
17559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17560 }
17561 {
17562 if (temp2)
17563 delete arg2;
17564 }
17565 return resultobj;
17566 fail:
17567 {
17568 if (temp2)
17569 delete arg2;
17570 }
17571 return NULL;
17572 }
17573
17574
17575 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17576 PyObject *resultobj = 0;
17577 wxImage *arg1 = (wxImage *) 0 ;
17578 wxString *arg2 = 0 ;
17579 wxString *arg3 = 0 ;
17580 bool result;
17581 void *argp1 = 0 ;
17582 int res1 = 0 ;
17583 bool temp2 = false ;
17584 bool temp3 = false ;
17585 PyObject * obj0 = 0 ;
17586 PyObject * obj1 = 0 ;
17587 PyObject * obj2 = 0 ;
17588 char * kwnames[] = {
17589 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17590 };
17591
17592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17594 if (!SWIG_IsOK(res1)) {
17595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17596 }
17597 arg1 = reinterpret_cast< wxImage * >(argp1);
17598 {
17599 arg2 = wxString_in_helper(obj1);
17600 if (arg2 == NULL) SWIG_fail;
17601 temp2 = true;
17602 }
17603 {
17604 arg3 = wxString_in_helper(obj2);
17605 if (arg3 == NULL) SWIG_fail;
17606 temp3 = true;
17607 }
17608 {
17609 PyThreadState* __tstate = wxPyBeginAllowThreads();
17610 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17611 wxPyEndAllowThreads(__tstate);
17612 if (PyErr_Occurred()) SWIG_fail;
17613 }
17614 {
17615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17616 }
17617 {
17618 if (temp2)
17619 delete arg2;
17620 }
17621 {
17622 if (temp3)
17623 delete arg3;
17624 }
17625 return resultobj;
17626 fail:
17627 {
17628 if (temp2)
17629 delete arg2;
17630 }
17631 {
17632 if (temp3)
17633 delete arg3;
17634 }
17635 return NULL;
17636 }
17637
17638
17639 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17640 PyObject *resultobj = 0;
17641 wxInputStream *arg1 = 0 ;
17642 bool result;
17643 wxPyInputStream *temp1 ;
17644 bool created1 ;
17645 PyObject * obj0 = 0 ;
17646 char * kwnames[] = {
17647 (char *) "stream", NULL
17648 };
17649
17650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17651 {
17652 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17653 arg1 = temp1->m_wxis;
17654 created1 = false;
17655 } else {
17656 PyErr_Clear(); // clear the failure of the wxPyConvert above
17657 arg1 = wxPyCBInputStream_create(obj0, false);
17658 if (arg1 == NULL) {
17659 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17660 SWIG_fail;
17661 }
17662 created1 = true;
17663 }
17664 }
17665 {
17666 PyThreadState* __tstate = wxPyBeginAllowThreads();
17667 result = (bool)wxImage::CanRead(*arg1);
17668 wxPyEndAllowThreads(__tstate);
17669 if (PyErr_Occurred()) SWIG_fail;
17670 }
17671 {
17672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17673 }
17674 {
17675 if (created1) delete arg1;
17676 }
17677 return resultobj;
17678 fail:
17679 {
17680 if (created1) delete arg1;
17681 }
17682 return NULL;
17683 }
17684
17685
17686 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17687 PyObject *resultobj = 0;
17688 wxImage *arg1 = (wxImage *) 0 ;
17689 wxInputStream *arg2 = 0 ;
17690 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17691 int arg4 = (int) -1 ;
17692 bool result;
17693 void *argp1 = 0 ;
17694 int res1 = 0 ;
17695 wxPyInputStream *temp2 ;
17696 bool created2 ;
17697 long val3 ;
17698 int ecode3 = 0 ;
17699 int val4 ;
17700 int ecode4 = 0 ;
17701 PyObject * obj0 = 0 ;
17702 PyObject * obj1 = 0 ;
17703 PyObject * obj2 = 0 ;
17704 PyObject * obj3 = 0 ;
17705 char * kwnames[] = {
17706 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17707 };
17708
17709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17711 if (!SWIG_IsOK(res1)) {
17712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17713 }
17714 arg1 = reinterpret_cast< wxImage * >(argp1);
17715 {
17716 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17717 arg2 = temp2->m_wxis;
17718 created2 = false;
17719 } else {
17720 PyErr_Clear(); // clear the failure of the wxPyConvert above
17721 arg2 = wxPyCBInputStream_create(obj1, false);
17722 if (arg2 == NULL) {
17723 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17724 SWIG_fail;
17725 }
17726 created2 = true;
17727 }
17728 }
17729 if (obj2) {
17730 ecode3 = SWIG_AsVal_long(obj2, &val3);
17731 if (!SWIG_IsOK(ecode3)) {
17732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17733 }
17734 arg3 = static_cast< long >(val3);
17735 }
17736 if (obj3) {
17737 ecode4 = SWIG_AsVal_int(obj3, &val4);
17738 if (!SWIG_IsOK(ecode4)) {
17739 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17740 }
17741 arg4 = static_cast< int >(val4);
17742 }
17743 {
17744 PyThreadState* __tstate = wxPyBeginAllowThreads();
17745 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17746 wxPyEndAllowThreads(__tstate);
17747 if (PyErr_Occurred()) SWIG_fail;
17748 }
17749 {
17750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17751 }
17752 {
17753 if (created2) delete arg2;
17754 }
17755 return resultobj;
17756 fail:
17757 {
17758 if (created2) delete arg2;
17759 }
17760 return NULL;
17761 }
17762
17763
17764 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17765 PyObject *resultobj = 0;
17766 wxImage *arg1 = (wxImage *) 0 ;
17767 wxInputStream *arg2 = 0 ;
17768 wxString *arg3 = 0 ;
17769 int arg4 = (int) -1 ;
17770 bool result;
17771 void *argp1 = 0 ;
17772 int res1 = 0 ;
17773 wxPyInputStream *temp2 ;
17774 bool created2 ;
17775 bool temp3 = false ;
17776 int val4 ;
17777 int ecode4 = 0 ;
17778 PyObject * obj0 = 0 ;
17779 PyObject * obj1 = 0 ;
17780 PyObject * obj2 = 0 ;
17781 PyObject * obj3 = 0 ;
17782 char * kwnames[] = {
17783 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17784 };
17785
17786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17788 if (!SWIG_IsOK(res1)) {
17789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17790 }
17791 arg1 = reinterpret_cast< wxImage * >(argp1);
17792 {
17793 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17794 arg2 = temp2->m_wxis;
17795 created2 = false;
17796 } else {
17797 PyErr_Clear(); // clear the failure of the wxPyConvert above
17798 arg2 = wxPyCBInputStream_create(obj1, false);
17799 if (arg2 == NULL) {
17800 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17801 SWIG_fail;
17802 }
17803 created2 = true;
17804 }
17805 }
17806 {
17807 arg3 = wxString_in_helper(obj2);
17808 if (arg3 == NULL) SWIG_fail;
17809 temp3 = true;
17810 }
17811 if (obj3) {
17812 ecode4 = SWIG_AsVal_int(obj3, &val4);
17813 if (!SWIG_IsOK(ecode4)) {
17814 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17815 }
17816 arg4 = static_cast< int >(val4);
17817 }
17818 {
17819 PyThreadState* __tstate = wxPyBeginAllowThreads();
17820 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17821 wxPyEndAllowThreads(__tstate);
17822 if (PyErr_Occurred()) SWIG_fail;
17823 }
17824 {
17825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17826 }
17827 {
17828 if (created2) delete arg2;
17829 }
17830 {
17831 if (temp3)
17832 delete arg3;
17833 }
17834 return resultobj;
17835 fail:
17836 {
17837 if (created2) delete arg2;
17838 }
17839 {
17840 if (temp3)
17841 delete arg3;
17842 }
17843 return NULL;
17844 }
17845
17846
17847 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17848 PyObject *resultobj = 0;
17849 wxImage *arg1 = (wxImage *) 0 ;
17850 bool result;
17851 void *argp1 = 0 ;
17852 int res1 = 0 ;
17853 PyObject *swig_obj[1] ;
17854
17855 if (!args) SWIG_fail;
17856 swig_obj[0] = args;
17857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17858 if (!SWIG_IsOK(res1)) {
17859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
17860 }
17861 arg1 = reinterpret_cast< wxImage * >(argp1);
17862 {
17863 PyThreadState* __tstate = wxPyBeginAllowThreads();
17864 result = (bool)(arg1)->IsOk();
17865 wxPyEndAllowThreads(__tstate);
17866 if (PyErr_Occurred()) SWIG_fail;
17867 }
17868 {
17869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17870 }
17871 return resultobj;
17872 fail:
17873 return NULL;
17874 }
17875
17876
17877 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17878 PyObject *resultobj = 0;
17879 wxImage *arg1 = (wxImage *) 0 ;
17880 int result;
17881 void *argp1 = 0 ;
17882 int res1 = 0 ;
17883 PyObject *swig_obj[1] ;
17884
17885 if (!args) SWIG_fail;
17886 swig_obj[0] = args;
17887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17888 if (!SWIG_IsOK(res1)) {
17889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17890 }
17891 arg1 = reinterpret_cast< wxImage * >(argp1);
17892 {
17893 PyThreadState* __tstate = wxPyBeginAllowThreads();
17894 result = (int)(arg1)->GetWidth();
17895 wxPyEndAllowThreads(__tstate);
17896 if (PyErr_Occurred()) SWIG_fail;
17897 }
17898 resultobj = SWIG_From_int(static_cast< int >(result));
17899 return resultobj;
17900 fail:
17901 return NULL;
17902 }
17903
17904
17905 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17906 PyObject *resultobj = 0;
17907 wxImage *arg1 = (wxImage *) 0 ;
17908 int result;
17909 void *argp1 = 0 ;
17910 int res1 = 0 ;
17911 PyObject *swig_obj[1] ;
17912
17913 if (!args) SWIG_fail;
17914 swig_obj[0] = args;
17915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17916 if (!SWIG_IsOK(res1)) {
17917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17918 }
17919 arg1 = reinterpret_cast< wxImage * >(argp1);
17920 {
17921 PyThreadState* __tstate = wxPyBeginAllowThreads();
17922 result = (int)(arg1)->GetHeight();
17923 wxPyEndAllowThreads(__tstate);
17924 if (PyErr_Occurred()) SWIG_fail;
17925 }
17926 resultobj = SWIG_From_int(static_cast< int >(result));
17927 return resultobj;
17928 fail:
17929 return NULL;
17930 }
17931
17932
17933 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17934 PyObject *resultobj = 0;
17935 wxImage *arg1 = (wxImage *) 0 ;
17936 wxSize result;
17937 void *argp1 = 0 ;
17938 int res1 = 0 ;
17939 PyObject *swig_obj[1] ;
17940
17941 if (!args) SWIG_fail;
17942 swig_obj[0] = args;
17943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17944 if (!SWIG_IsOK(res1)) {
17945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
17946 }
17947 arg1 = reinterpret_cast< wxImage * >(argp1);
17948 {
17949 PyThreadState* __tstate = wxPyBeginAllowThreads();
17950 result = wxImage_GetSize(arg1);
17951 wxPyEndAllowThreads(__tstate);
17952 if (PyErr_Occurred()) SWIG_fail;
17953 }
17954 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
17955 return resultobj;
17956 fail:
17957 return NULL;
17958 }
17959
17960
17961 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17962 PyObject *resultobj = 0;
17963 wxImage *arg1 = (wxImage *) 0 ;
17964 wxRect *arg2 = 0 ;
17965 SwigValueWrapper<wxImage > result;
17966 void *argp1 = 0 ;
17967 int res1 = 0 ;
17968 wxRect temp2 ;
17969 PyObject * obj0 = 0 ;
17970 PyObject * obj1 = 0 ;
17971 char * kwnames[] = {
17972 (char *) "self",(char *) "rect", NULL
17973 };
17974
17975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
17976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17977 if (!SWIG_IsOK(res1)) {
17978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
17979 }
17980 arg1 = reinterpret_cast< wxImage * >(argp1);
17981 {
17982 arg2 = &temp2;
17983 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17984 }
17985 {
17986 PyThreadState* __tstate = wxPyBeginAllowThreads();
17987 result = (arg1)->GetSubImage((wxRect const &)*arg2);
17988 wxPyEndAllowThreads(__tstate);
17989 if (PyErr_Occurred()) SWIG_fail;
17990 }
17991 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
17992 return resultobj;
17993 fail:
17994 return NULL;
17995 }
17996
17997
17998 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17999 PyObject *resultobj = 0;
18000 wxImage *arg1 = (wxImage *) 0 ;
18001 wxSize *arg2 = 0 ;
18002 wxPoint *arg3 = 0 ;
18003 int arg4 = (int) -1 ;
18004 int arg5 = (int) -1 ;
18005 int arg6 = (int) -1 ;
18006 SwigValueWrapper<wxImage > result;
18007 void *argp1 = 0 ;
18008 int res1 = 0 ;
18009 wxSize temp2 ;
18010 wxPoint temp3 ;
18011 int val4 ;
18012 int ecode4 = 0 ;
18013 int val5 ;
18014 int ecode5 = 0 ;
18015 int val6 ;
18016 int ecode6 = 0 ;
18017 PyObject * obj0 = 0 ;
18018 PyObject * obj1 = 0 ;
18019 PyObject * obj2 = 0 ;
18020 PyObject * obj3 = 0 ;
18021 PyObject * obj4 = 0 ;
18022 PyObject * obj5 = 0 ;
18023 char * kwnames[] = {
18024 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18025 };
18026
18027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18029 if (!SWIG_IsOK(res1)) {
18030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18031 }
18032 arg1 = reinterpret_cast< wxImage * >(argp1);
18033 {
18034 arg2 = &temp2;
18035 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18036 }
18037 {
18038 arg3 = &temp3;
18039 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18040 }
18041 if (obj3) {
18042 ecode4 = SWIG_AsVal_int(obj3, &val4);
18043 if (!SWIG_IsOK(ecode4)) {
18044 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18045 }
18046 arg4 = static_cast< int >(val4);
18047 }
18048 if (obj4) {
18049 ecode5 = SWIG_AsVal_int(obj4, &val5);
18050 if (!SWIG_IsOK(ecode5)) {
18051 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18052 }
18053 arg5 = static_cast< int >(val5);
18054 }
18055 if (obj5) {
18056 ecode6 = SWIG_AsVal_int(obj5, &val6);
18057 if (!SWIG_IsOK(ecode6)) {
18058 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18059 }
18060 arg6 = static_cast< int >(val6);
18061 }
18062 {
18063 PyThreadState* __tstate = wxPyBeginAllowThreads();
18064 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18065 wxPyEndAllowThreads(__tstate);
18066 if (PyErr_Occurred()) SWIG_fail;
18067 }
18068 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18069 return resultobj;
18070 fail:
18071 return NULL;
18072 }
18073
18074
18075 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18076 PyObject *resultobj = 0;
18077 wxImage *arg1 = (wxImage *) 0 ;
18078 SwigValueWrapper<wxImage > result;
18079 void *argp1 = 0 ;
18080 int res1 = 0 ;
18081 PyObject *swig_obj[1] ;
18082
18083 if (!args) SWIG_fail;
18084 swig_obj[0] = args;
18085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18086 if (!SWIG_IsOK(res1)) {
18087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18088 }
18089 arg1 = reinterpret_cast< wxImage * >(argp1);
18090 {
18091 PyThreadState* __tstate = wxPyBeginAllowThreads();
18092 result = (arg1)->Copy();
18093 wxPyEndAllowThreads(__tstate);
18094 if (PyErr_Occurred()) SWIG_fail;
18095 }
18096 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18097 return resultobj;
18098 fail:
18099 return NULL;
18100 }
18101
18102
18103 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18104 PyObject *resultobj = 0;
18105 wxImage *arg1 = (wxImage *) 0 ;
18106 wxImage *arg2 = 0 ;
18107 int arg3 ;
18108 int arg4 ;
18109 void *argp1 = 0 ;
18110 int res1 = 0 ;
18111 void *argp2 = 0 ;
18112 int res2 = 0 ;
18113 int val3 ;
18114 int ecode3 = 0 ;
18115 int val4 ;
18116 int ecode4 = 0 ;
18117 PyObject * obj0 = 0 ;
18118 PyObject * obj1 = 0 ;
18119 PyObject * obj2 = 0 ;
18120 PyObject * obj3 = 0 ;
18121 char * kwnames[] = {
18122 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18123 };
18124
18125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18127 if (!SWIG_IsOK(res1)) {
18128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18129 }
18130 arg1 = reinterpret_cast< wxImage * >(argp1);
18131 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18132 if (!SWIG_IsOK(res2)) {
18133 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18134 }
18135 if (!argp2) {
18136 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18137 }
18138 arg2 = reinterpret_cast< wxImage * >(argp2);
18139 ecode3 = SWIG_AsVal_int(obj2, &val3);
18140 if (!SWIG_IsOK(ecode3)) {
18141 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18142 }
18143 arg3 = static_cast< int >(val3);
18144 ecode4 = SWIG_AsVal_int(obj3, &val4);
18145 if (!SWIG_IsOK(ecode4)) {
18146 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18147 }
18148 arg4 = static_cast< int >(val4);
18149 {
18150 PyThreadState* __tstate = wxPyBeginAllowThreads();
18151 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18152 wxPyEndAllowThreads(__tstate);
18153 if (PyErr_Occurred()) SWIG_fail;
18154 }
18155 resultobj = SWIG_Py_Void();
18156 return resultobj;
18157 fail:
18158 return NULL;
18159 }
18160
18161
18162 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18163 PyObject *resultobj = 0;
18164 wxImage *arg1 = (wxImage *) 0 ;
18165 PyObject *result = 0 ;
18166 void *argp1 = 0 ;
18167 int res1 = 0 ;
18168 PyObject *swig_obj[1] ;
18169
18170 if (!args) SWIG_fail;
18171 swig_obj[0] = args;
18172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18173 if (!SWIG_IsOK(res1)) {
18174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18175 }
18176 arg1 = reinterpret_cast< wxImage * >(argp1);
18177 {
18178 PyThreadState* __tstate = wxPyBeginAllowThreads();
18179 result = (PyObject *)wxImage_GetData(arg1);
18180 wxPyEndAllowThreads(__tstate);
18181 if (PyErr_Occurred()) SWIG_fail;
18182 }
18183 resultobj = result;
18184 return resultobj;
18185 fail:
18186 return NULL;
18187 }
18188
18189
18190 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18191 PyObject *resultobj = 0;
18192 wxImage *arg1 = (wxImage *) 0 ;
18193 buffer arg2 ;
18194 int arg3 ;
18195 void *argp1 = 0 ;
18196 int res1 = 0 ;
18197 Py_ssize_t temp2 ;
18198 PyObject * obj0 = 0 ;
18199 PyObject * obj1 = 0 ;
18200 char * kwnames[] = {
18201 (char *) "self",(char *) "data", NULL
18202 };
18203
18204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18206 if (!SWIG_IsOK(res1)) {
18207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18208 }
18209 arg1 = reinterpret_cast< wxImage * >(argp1);
18210 {
18211 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18212 arg3 = (int)temp2;
18213 }
18214 {
18215 PyThreadState* __tstate = wxPyBeginAllowThreads();
18216 wxImage_SetData(arg1,arg2,arg3);
18217 wxPyEndAllowThreads(__tstate);
18218 if (PyErr_Occurred()) SWIG_fail;
18219 }
18220 resultobj = SWIG_Py_Void();
18221 return resultobj;
18222 fail:
18223 return NULL;
18224 }
18225
18226
18227 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18228 PyObject *resultobj = 0;
18229 wxImage *arg1 = (wxImage *) 0 ;
18230 PyObject *result = 0 ;
18231 void *argp1 = 0 ;
18232 int res1 = 0 ;
18233 PyObject *swig_obj[1] ;
18234
18235 if (!args) SWIG_fail;
18236 swig_obj[0] = args;
18237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18238 if (!SWIG_IsOK(res1)) {
18239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18240 }
18241 arg1 = reinterpret_cast< wxImage * >(argp1);
18242 {
18243 PyThreadState* __tstate = wxPyBeginAllowThreads();
18244 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18245 wxPyEndAllowThreads(__tstate);
18246 if (PyErr_Occurred()) SWIG_fail;
18247 }
18248 resultobj = result;
18249 return resultobj;
18250 fail:
18251 return NULL;
18252 }
18253
18254
18255 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18256 PyObject *resultobj = 0;
18257 wxImage *arg1 = (wxImage *) 0 ;
18258 buffer arg2 ;
18259 int arg3 ;
18260 void *argp1 = 0 ;
18261 int res1 = 0 ;
18262 Py_ssize_t temp2 ;
18263 PyObject * obj0 = 0 ;
18264 PyObject * obj1 = 0 ;
18265 char * kwnames[] = {
18266 (char *) "self",(char *) "data", NULL
18267 };
18268
18269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18271 if (!SWIG_IsOK(res1)) {
18272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18273 }
18274 arg1 = reinterpret_cast< wxImage * >(argp1);
18275 {
18276 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18277 arg3 = (int)temp2;
18278 }
18279 {
18280 PyThreadState* __tstate = wxPyBeginAllowThreads();
18281 wxImage_SetDataBuffer(arg1,arg2,arg3);
18282 wxPyEndAllowThreads(__tstate);
18283 if (PyErr_Occurred()) SWIG_fail;
18284 }
18285 resultobj = SWIG_Py_Void();
18286 return resultobj;
18287 fail:
18288 return NULL;
18289 }
18290
18291
18292 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18293 PyObject *resultobj = 0;
18294 wxImage *arg1 = (wxImage *) 0 ;
18295 PyObject *result = 0 ;
18296 void *argp1 = 0 ;
18297 int res1 = 0 ;
18298 PyObject *swig_obj[1] ;
18299
18300 if (!args) SWIG_fail;
18301 swig_obj[0] = args;
18302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18303 if (!SWIG_IsOK(res1)) {
18304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18305 }
18306 arg1 = reinterpret_cast< wxImage * >(argp1);
18307 {
18308 PyThreadState* __tstate = wxPyBeginAllowThreads();
18309 result = (PyObject *)wxImage_GetAlphaData(arg1);
18310 wxPyEndAllowThreads(__tstate);
18311 if (PyErr_Occurred()) SWIG_fail;
18312 }
18313 resultobj = result;
18314 return resultobj;
18315 fail:
18316 return NULL;
18317 }
18318
18319
18320 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18321 PyObject *resultobj = 0;
18322 wxImage *arg1 = (wxImage *) 0 ;
18323 buffer arg2 ;
18324 int arg3 ;
18325 void *argp1 = 0 ;
18326 int res1 = 0 ;
18327 Py_ssize_t temp2 ;
18328 PyObject * obj0 = 0 ;
18329 PyObject * obj1 = 0 ;
18330 char * kwnames[] = {
18331 (char *) "self",(char *) "alpha", NULL
18332 };
18333
18334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18336 if (!SWIG_IsOK(res1)) {
18337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18338 }
18339 arg1 = reinterpret_cast< wxImage * >(argp1);
18340 {
18341 if (obj1 != Py_None) {
18342 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18343 arg3 = (int)temp2;
18344 }
18345 }
18346 {
18347 PyThreadState* __tstate = wxPyBeginAllowThreads();
18348 wxImage_SetAlphaData(arg1,arg2,arg3);
18349 wxPyEndAllowThreads(__tstate);
18350 if (PyErr_Occurred()) SWIG_fail;
18351 }
18352 resultobj = SWIG_Py_Void();
18353 return resultobj;
18354 fail:
18355 return NULL;
18356 }
18357
18358
18359 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18360 PyObject *resultobj = 0;
18361 wxImage *arg1 = (wxImage *) 0 ;
18362 PyObject *result = 0 ;
18363 void *argp1 = 0 ;
18364 int res1 = 0 ;
18365 PyObject *swig_obj[1] ;
18366
18367 if (!args) SWIG_fail;
18368 swig_obj[0] = args;
18369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18370 if (!SWIG_IsOK(res1)) {
18371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18372 }
18373 arg1 = reinterpret_cast< wxImage * >(argp1);
18374 {
18375 PyThreadState* __tstate = wxPyBeginAllowThreads();
18376 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18377 wxPyEndAllowThreads(__tstate);
18378 if (PyErr_Occurred()) SWIG_fail;
18379 }
18380 resultobj = result;
18381 return resultobj;
18382 fail:
18383 return NULL;
18384 }
18385
18386
18387 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18388 PyObject *resultobj = 0;
18389 wxImage *arg1 = (wxImage *) 0 ;
18390 buffer arg2 ;
18391 int arg3 ;
18392 void *argp1 = 0 ;
18393 int res1 = 0 ;
18394 Py_ssize_t temp2 ;
18395 PyObject * obj0 = 0 ;
18396 PyObject * obj1 = 0 ;
18397 char * kwnames[] = {
18398 (char *) "self",(char *) "alpha", NULL
18399 };
18400
18401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18403 if (!SWIG_IsOK(res1)) {
18404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18405 }
18406 arg1 = reinterpret_cast< wxImage * >(argp1);
18407 {
18408 if (obj1 != Py_None) {
18409 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18410 arg3 = (int)temp2;
18411 }
18412 }
18413 {
18414 PyThreadState* __tstate = wxPyBeginAllowThreads();
18415 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18416 wxPyEndAllowThreads(__tstate);
18417 if (PyErr_Occurred()) SWIG_fail;
18418 }
18419 resultobj = SWIG_Py_Void();
18420 return resultobj;
18421 fail:
18422 return NULL;
18423 }
18424
18425
18426 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18427 PyObject *resultobj = 0;
18428 wxImage *arg1 = (wxImage *) 0 ;
18429 byte arg2 ;
18430 byte arg3 ;
18431 byte arg4 ;
18432 void *argp1 = 0 ;
18433 int res1 = 0 ;
18434 unsigned char val2 ;
18435 int ecode2 = 0 ;
18436 unsigned char val3 ;
18437 int ecode3 = 0 ;
18438 unsigned char val4 ;
18439 int ecode4 = 0 ;
18440 PyObject * obj0 = 0 ;
18441 PyObject * obj1 = 0 ;
18442 PyObject * obj2 = 0 ;
18443 PyObject * obj3 = 0 ;
18444 char * kwnames[] = {
18445 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18446 };
18447
18448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18450 if (!SWIG_IsOK(res1)) {
18451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18452 }
18453 arg1 = reinterpret_cast< wxImage * >(argp1);
18454 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18455 if (!SWIG_IsOK(ecode2)) {
18456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18457 }
18458 arg2 = static_cast< byte >(val2);
18459 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18460 if (!SWIG_IsOK(ecode3)) {
18461 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18462 }
18463 arg3 = static_cast< byte >(val3);
18464 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18465 if (!SWIG_IsOK(ecode4)) {
18466 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18467 }
18468 arg4 = static_cast< byte >(val4);
18469 {
18470 PyThreadState* __tstate = wxPyBeginAllowThreads();
18471 (arg1)->SetMaskColour(arg2,arg3,arg4);
18472 wxPyEndAllowThreads(__tstate);
18473 if (PyErr_Occurred()) SWIG_fail;
18474 }
18475 resultobj = SWIG_Py_Void();
18476 return resultobj;
18477 fail:
18478 return NULL;
18479 }
18480
18481
18482 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18483 PyObject *resultobj = 0;
18484 wxImage *arg1 = (wxImage *) 0 ;
18485 byte *arg2 = (byte *) 0 ;
18486 byte *arg3 = (byte *) 0 ;
18487 byte *arg4 = (byte *) 0 ;
18488 void *argp1 = 0 ;
18489 int res1 = 0 ;
18490 byte temp2 ;
18491 int res2 = SWIG_TMPOBJ ;
18492 byte temp3 ;
18493 int res3 = SWIG_TMPOBJ ;
18494 byte temp4 ;
18495 int res4 = SWIG_TMPOBJ ;
18496 PyObject *swig_obj[1] ;
18497
18498 arg2 = &temp2;
18499 arg3 = &temp3;
18500 arg4 = &temp4;
18501 if (!args) SWIG_fail;
18502 swig_obj[0] = args;
18503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18504 if (!SWIG_IsOK(res1)) {
18505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18506 }
18507 arg1 = reinterpret_cast< wxImage * >(argp1);
18508 {
18509 PyThreadState* __tstate = wxPyBeginAllowThreads();
18510 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18511 wxPyEndAllowThreads(__tstate);
18512 if (PyErr_Occurred()) SWIG_fail;
18513 }
18514 resultobj = SWIG_Py_Void();
18515 if (SWIG_IsTmpObj(res2)) {
18516 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18517 } else {
18518 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18519 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18520 }
18521 if (SWIG_IsTmpObj(res3)) {
18522 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18523 } else {
18524 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18525 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18526 }
18527 if (SWIG_IsTmpObj(res4)) {
18528 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18529 } else {
18530 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18531 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18532 }
18533 return resultobj;
18534 fail:
18535 return NULL;
18536 }
18537
18538
18539 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18540 PyObject *resultobj = 0;
18541 wxImage *arg1 = (wxImage *) 0 ;
18542 byte result;
18543 void *argp1 = 0 ;
18544 int res1 = 0 ;
18545 PyObject *swig_obj[1] ;
18546
18547 if (!args) SWIG_fail;
18548 swig_obj[0] = args;
18549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18550 if (!SWIG_IsOK(res1)) {
18551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18552 }
18553 arg1 = reinterpret_cast< wxImage * >(argp1);
18554 {
18555 PyThreadState* __tstate = wxPyBeginAllowThreads();
18556 result = (byte)(arg1)->GetMaskRed();
18557 wxPyEndAllowThreads(__tstate);
18558 if (PyErr_Occurred()) SWIG_fail;
18559 }
18560 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18561 return resultobj;
18562 fail:
18563 return NULL;
18564 }
18565
18566
18567 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18568 PyObject *resultobj = 0;
18569 wxImage *arg1 = (wxImage *) 0 ;
18570 byte result;
18571 void *argp1 = 0 ;
18572 int res1 = 0 ;
18573 PyObject *swig_obj[1] ;
18574
18575 if (!args) SWIG_fail;
18576 swig_obj[0] = args;
18577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18578 if (!SWIG_IsOK(res1)) {
18579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18580 }
18581 arg1 = reinterpret_cast< wxImage * >(argp1);
18582 {
18583 PyThreadState* __tstate = wxPyBeginAllowThreads();
18584 result = (byte)(arg1)->GetMaskGreen();
18585 wxPyEndAllowThreads(__tstate);
18586 if (PyErr_Occurred()) SWIG_fail;
18587 }
18588 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18589 return resultobj;
18590 fail:
18591 return NULL;
18592 }
18593
18594
18595 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18596 PyObject *resultobj = 0;
18597 wxImage *arg1 = (wxImage *) 0 ;
18598 byte result;
18599 void *argp1 = 0 ;
18600 int res1 = 0 ;
18601 PyObject *swig_obj[1] ;
18602
18603 if (!args) SWIG_fail;
18604 swig_obj[0] = args;
18605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18606 if (!SWIG_IsOK(res1)) {
18607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18608 }
18609 arg1 = reinterpret_cast< wxImage * >(argp1);
18610 {
18611 PyThreadState* __tstate = wxPyBeginAllowThreads();
18612 result = (byte)(arg1)->GetMaskBlue();
18613 wxPyEndAllowThreads(__tstate);
18614 if (PyErr_Occurred()) SWIG_fail;
18615 }
18616 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18617 return resultobj;
18618 fail:
18619 return NULL;
18620 }
18621
18622
18623 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18624 PyObject *resultobj = 0;
18625 wxImage *arg1 = (wxImage *) 0 ;
18626 bool arg2 = (bool) true ;
18627 void *argp1 = 0 ;
18628 int res1 = 0 ;
18629 bool val2 ;
18630 int ecode2 = 0 ;
18631 PyObject * obj0 = 0 ;
18632 PyObject * obj1 = 0 ;
18633 char * kwnames[] = {
18634 (char *) "self",(char *) "mask", NULL
18635 };
18636
18637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18639 if (!SWIG_IsOK(res1)) {
18640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18641 }
18642 arg1 = reinterpret_cast< wxImage * >(argp1);
18643 if (obj1) {
18644 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18645 if (!SWIG_IsOK(ecode2)) {
18646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18647 }
18648 arg2 = static_cast< bool >(val2);
18649 }
18650 {
18651 PyThreadState* __tstate = wxPyBeginAllowThreads();
18652 (arg1)->SetMask(arg2);
18653 wxPyEndAllowThreads(__tstate);
18654 if (PyErr_Occurred()) SWIG_fail;
18655 }
18656 resultobj = SWIG_Py_Void();
18657 return resultobj;
18658 fail:
18659 return NULL;
18660 }
18661
18662
18663 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18664 PyObject *resultobj = 0;
18665 wxImage *arg1 = (wxImage *) 0 ;
18666 bool result;
18667 void *argp1 = 0 ;
18668 int res1 = 0 ;
18669 PyObject *swig_obj[1] ;
18670
18671 if (!args) SWIG_fail;
18672 swig_obj[0] = args;
18673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18674 if (!SWIG_IsOK(res1)) {
18675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18676 }
18677 arg1 = reinterpret_cast< wxImage * >(argp1);
18678 {
18679 PyThreadState* __tstate = wxPyBeginAllowThreads();
18680 result = (bool)(arg1)->HasMask();
18681 wxPyEndAllowThreads(__tstate);
18682 if (PyErr_Occurred()) SWIG_fail;
18683 }
18684 {
18685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18686 }
18687 return resultobj;
18688 fail:
18689 return NULL;
18690 }
18691
18692
18693 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18694 PyObject *resultobj = 0;
18695 wxImage *arg1 = (wxImage *) 0 ;
18696 double arg2 ;
18697 wxPoint *arg3 = 0 ;
18698 bool arg4 = (bool) true ;
18699 wxPoint *arg5 = (wxPoint *) NULL ;
18700 SwigValueWrapper<wxImage > result;
18701 void *argp1 = 0 ;
18702 int res1 = 0 ;
18703 double val2 ;
18704 int ecode2 = 0 ;
18705 wxPoint temp3 ;
18706 bool val4 ;
18707 int ecode4 = 0 ;
18708 void *argp5 = 0 ;
18709 int res5 = 0 ;
18710 PyObject * obj0 = 0 ;
18711 PyObject * obj1 = 0 ;
18712 PyObject * obj2 = 0 ;
18713 PyObject * obj3 = 0 ;
18714 PyObject * obj4 = 0 ;
18715 char * kwnames[] = {
18716 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18717 };
18718
18719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18721 if (!SWIG_IsOK(res1)) {
18722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18723 }
18724 arg1 = reinterpret_cast< wxImage * >(argp1);
18725 ecode2 = SWIG_AsVal_double(obj1, &val2);
18726 if (!SWIG_IsOK(ecode2)) {
18727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18728 }
18729 arg2 = static_cast< double >(val2);
18730 {
18731 arg3 = &temp3;
18732 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18733 }
18734 if (obj3) {
18735 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18736 if (!SWIG_IsOK(ecode4)) {
18737 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18738 }
18739 arg4 = static_cast< bool >(val4);
18740 }
18741 if (obj4) {
18742 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18743 if (!SWIG_IsOK(res5)) {
18744 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
18745 }
18746 arg5 = reinterpret_cast< wxPoint * >(argp5);
18747 }
18748 {
18749 PyThreadState* __tstate = wxPyBeginAllowThreads();
18750 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18751 wxPyEndAllowThreads(__tstate);
18752 if (PyErr_Occurred()) SWIG_fail;
18753 }
18754 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18755 return resultobj;
18756 fail:
18757 return NULL;
18758 }
18759
18760
18761 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18762 PyObject *resultobj = 0;
18763 wxImage *arg1 = (wxImage *) 0 ;
18764 bool arg2 = (bool) true ;
18765 SwigValueWrapper<wxImage > result;
18766 void *argp1 = 0 ;
18767 int res1 = 0 ;
18768 bool val2 ;
18769 int ecode2 = 0 ;
18770 PyObject * obj0 = 0 ;
18771 PyObject * obj1 = 0 ;
18772 char * kwnames[] = {
18773 (char *) "self",(char *) "clockwise", NULL
18774 };
18775
18776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18778 if (!SWIG_IsOK(res1)) {
18779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18780 }
18781 arg1 = reinterpret_cast< wxImage * >(argp1);
18782 if (obj1) {
18783 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18784 if (!SWIG_IsOK(ecode2)) {
18785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18786 }
18787 arg2 = static_cast< bool >(val2);
18788 }
18789 {
18790 PyThreadState* __tstate = wxPyBeginAllowThreads();
18791 result = (arg1)->Rotate90(arg2);
18792 wxPyEndAllowThreads(__tstate);
18793 if (PyErr_Occurred()) SWIG_fail;
18794 }
18795 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18796 return resultobj;
18797 fail:
18798 return NULL;
18799 }
18800
18801
18802 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18803 PyObject *resultobj = 0;
18804 wxImage *arg1 = (wxImage *) 0 ;
18805 bool arg2 = (bool) true ;
18806 SwigValueWrapper<wxImage > result;
18807 void *argp1 = 0 ;
18808 int res1 = 0 ;
18809 bool val2 ;
18810 int ecode2 = 0 ;
18811 PyObject * obj0 = 0 ;
18812 PyObject * obj1 = 0 ;
18813 char * kwnames[] = {
18814 (char *) "self",(char *) "horizontally", NULL
18815 };
18816
18817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18819 if (!SWIG_IsOK(res1)) {
18820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18821 }
18822 arg1 = reinterpret_cast< wxImage * >(argp1);
18823 if (obj1) {
18824 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18825 if (!SWIG_IsOK(ecode2)) {
18826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18827 }
18828 arg2 = static_cast< bool >(val2);
18829 }
18830 {
18831 PyThreadState* __tstate = wxPyBeginAllowThreads();
18832 result = (arg1)->Mirror(arg2);
18833 wxPyEndAllowThreads(__tstate);
18834 if (PyErr_Occurred()) SWIG_fail;
18835 }
18836 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18837 return resultobj;
18838 fail:
18839 return NULL;
18840 }
18841
18842
18843 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18844 PyObject *resultobj = 0;
18845 wxImage *arg1 = (wxImage *) 0 ;
18846 byte arg2 ;
18847 byte arg3 ;
18848 byte arg4 ;
18849 byte arg5 ;
18850 byte arg6 ;
18851 byte arg7 ;
18852 void *argp1 = 0 ;
18853 int res1 = 0 ;
18854 unsigned char val2 ;
18855 int ecode2 = 0 ;
18856 unsigned char val3 ;
18857 int ecode3 = 0 ;
18858 unsigned char val4 ;
18859 int ecode4 = 0 ;
18860 unsigned char val5 ;
18861 int ecode5 = 0 ;
18862 unsigned char val6 ;
18863 int ecode6 = 0 ;
18864 unsigned char val7 ;
18865 int ecode7 = 0 ;
18866 PyObject * obj0 = 0 ;
18867 PyObject * obj1 = 0 ;
18868 PyObject * obj2 = 0 ;
18869 PyObject * obj3 = 0 ;
18870 PyObject * obj4 = 0 ;
18871 PyObject * obj5 = 0 ;
18872 PyObject * obj6 = 0 ;
18873 char * kwnames[] = {
18874 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18875 };
18876
18877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18879 if (!SWIG_IsOK(res1)) {
18880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18881 }
18882 arg1 = reinterpret_cast< wxImage * >(argp1);
18883 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18884 if (!SWIG_IsOK(ecode2)) {
18885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18886 }
18887 arg2 = static_cast< byte >(val2);
18888 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18889 if (!SWIG_IsOK(ecode3)) {
18890 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18891 }
18892 arg3 = static_cast< byte >(val3);
18893 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18894 if (!SWIG_IsOK(ecode4)) {
18895 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18896 }
18897 arg4 = static_cast< byte >(val4);
18898 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18899 if (!SWIG_IsOK(ecode5)) {
18900 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18901 }
18902 arg5 = static_cast< byte >(val5);
18903 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18904 if (!SWIG_IsOK(ecode6)) {
18905 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18906 }
18907 arg6 = static_cast< byte >(val6);
18908 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18909 if (!SWIG_IsOK(ecode7)) {
18910 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18911 }
18912 arg7 = static_cast< byte >(val7);
18913 {
18914 PyThreadState* __tstate = wxPyBeginAllowThreads();
18915 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18916 wxPyEndAllowThreads(__tstate);
18917 if (PyErr_Occurred()) SWIG_fail;
18918 }
18919 resultobj = SWIG_Py_Void();
18920 return resultobj;
18921 fail:
18922 return NULL;
18923 }
18924
18925
18926 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18927 PyObject *resultobj = 0;
18928 wxImage *arg1 = (wxImage *) 0 ;
18929 double arg2 = (double) 0.299 ;
18930 double arg3 = (double) 0.587 ;
18931 double arg4 = (double) 0.114 ;
18932 SwigValueWrapper<wxImage > result;
18933 void *argp1 = 0 ;
18934 int res1 = 0 ;
18935 double val2 ;
18936 int ecode2 = 0 ;
18937 double val3 ;
18938 int ecode3 = 0 ;
18939 double val4 ;
18940 int ecode4 = 0 ;
18941 PyObject * obj0 = 0 ;
18942 PyObject * obj1 = 0 ;
18943 PyObject * obj2 = 0 ;
18944 PyObject * obj3 = 0 ;
18945 char * kwnames[] = {
18946 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
18947 };
18948
18949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18951 if (!SWIG_IsOK(res1)) {
18952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
18953 }
18954 arg1 = reinterpret_cast< wxImage * >(argp1);
18955 if (obj1) {
18956 ecode2 = SWIG_AsVal_double(obj1, &val2);
18957 if (!SWIG_IsOK(ecode2)) {
18958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
18959 }
18960 arg2 = static_cast< double >(val2);
18961 }
18962 if (obj2) {
18963 ecode3 = SWIG_AsVal_double(obj2, &val3);
18964 if (!SWIG_IsOK(ecode3)) {
18965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
18966 }
18967 arg3 = static_cast< double >(val3);
18968 }
18969 if (obj3) {
18970 ecode4 = SWIG_AsVal_double(obj3, &val4);
18971 if (!SWIG_IsOK(ecode4)) {
18972 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
18973 }
18974 arg4 = static_cast< double >(val4);
18975 }
18976 {
18977 PyThreadState* __tstate = wxPyBeginAllowThreads();
18978 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
18979 wxPyEndAllowThreads(__tstate);
18980 if (PyErr_Occurred()) SWIG_fail;
18981 }
18982 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18983 return resultobj;
18984 fail:
18985 return NULL;
18986 }
18987
18988
18989 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18990 PyObject *resultobj = 0;
18991 wxImage *arg1 = (wxImage *) 0 ;
18992 byte arg2 ;
18993 byte arg3 ;
18994 byte arg4 ;
18995 SwigValueWrapper<wxImage > result;
18996 void *argp1 = 0 ;
18997 int res1 = 0 ;
18998 unsigned char val2 ;
18999 int ecode2 = 0 ;
19000 unsigned char val3 ;
19001 int ecode3 = 0 ;
19002 unsigned char val4 ;
19003 int ecode4 = 0 ;
19004 PyObject * obj0 = 0 ;
19005 PyObject * obj1 = 0 ;
19006 PyObject * obj2 = 0 ;
19007 PyObject * obj3 = 0 ;
19008 char * kwnames[] = {
19009 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19010 };
19011
19012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19014 if (!SWIG_IsOK(res1)) {
19015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19016 }
19017 arg1 = reinterpret_cast< wxImage * >(argp1);
19018 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19019 if (!SWIG_IsOK(ecode2)) {
19020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19021 }
19022 arg2 = static_cast< byte >(val2);
19023 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19024 if (!SWIG_IsOK(ecode3)) {
19025 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19026 }
19027 arg3 = static_cast< byte >(val3);
19028 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19029 if (!SWIG_IsOK(ecode4)) {
19030 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19031 }
19032 arg4 = static_cast< byte >(val4);
19033 {
19034 PyThreadState* __tstate = wxPyBeginAllowThreads();
19035 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19036 wxPyEndAllowThreads(__tstate);
19037 if (PyErr_Occurred()) SWIG_fail;
19038 }
19039 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19040 return resultobj;
19041 fail:
19042 return NULL;
19043 }
19044
19045
19046 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19047 PyObject *resultobj = 0;
19048 wxImage *arg1 = (wxImage *) 0 ;
19049 wxString *arg2 = 0 ;
19050 wxString *arg3 = 0 ;
19051 void *argp1 = 0 ;
19052 int res1 = 0 ;
19053 bool temp2 = false ;
19054 bool temp3 = false ;
19055 PyObject * obj0 = 0 ;
19056 PyObject * obj1 = 0 ;
19057 PyObject * obj2 = 0 ;
19058 char * kwnames[] = {
19059 (char *) "self",(char *) "name",(char *) "value", NULL
19060 };
19061
19062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19064 if (!SWIG_IsOK(res1)) {
19065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19066 }
19067 arg1 = reinterpret_cast< wxImage * >(argp1);
19068 {
19069 arg2 = wxString_in_helper(obj1);
19070 if (arg2 == NULL) SWIG_fail;
19071 temp2 = true;
19072 }
19073 {
19074 arg3 = wxString_in_helper(obj2);
19075 if (arg3 == NULL) SWIG_fail;
19076 temp3 = true;
19077 }
19078 {
19079 PyThreadState* __tstate = wxPyBeginAllowThreads();
19080 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19081 wxPyEndAllowThreads(__tstate);
19082 if (PyErr_Occurred()) SWIG_fail;
19083 }
19084 resultobj = SWIG_Py_Void();
19085 {
19086 if (temp2)
19087 delete arg2;
19088 }
19089 {
19090 if (temp3)
19091 delete arg3;
19092 }
19093 return resultobj;
19094 fail:
19095 {
19096 if (temp2)
19097 delete arg2;
19098 }
19099 {
19100 if (temp3)
19101 delete arg3;
19102 }
19103 return NULL;
19104 }
19105
19106
19107 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19108 PyObject *resultobj = 0;
19109 wxImage *arg1 = (wxImage *) 0 ;
19110 wxString *arg2 = 0 ;
19111 int arg3 ;
19112 void *argp1 = 0 ;
19113 int res1 = 0 ;
19114 bool temp2 = false ;
19115 int val3 ;
19116 int ecode3 = 0 ;
19117 PyObject * obj0 = 0 ;
19118 PyObject * obj1 = 0 ;
19119 PyObject * obj2 = 0 ;
19120 char * kwnames[] = {
19121 (char *) "self",(char *) "name",(char *) "value", NULL
19122 };
19123
19124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19126 if (!SWIG_IsOK(res1)) {
19127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19128 }
19129 arg1 = reinterpret_cast< wxImage * >(argp1);
19130 {
19131 arg2 = wxString_in_helper(obj1);
19132 if (arg2 == NULL) SWIG_fail;
19133 temp2 = true;
19134 }
19135 ecode3 = SWIG_AsVal_int(obj2, &val3);
19136 if (!SWIG_IsOK(ecode3)) {
19137 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19138 }
19139 arg3 = static_cast< int >(val3);
19140 {
19141 PyThreadState* __tstate = wxPyBeginAllowThreads();
19142 (arg1)->SetOption((wxString const &)*arg2,arg3);
19143 wxPyEndAllowThreads(__tstate);
19144 if (PyErr_Occurred()) SWIG_fail;
19145 }
19146 resultobj = SWIG_Py_Void();
19147 {
19148 if (temp2)
19149 delete arg2;
19150 }
19151 return resultobj;
19152 fail:
19153 {
19154 if (temp2)
19155 delete arg2;
19156 }
19157 return NULL;
19158 }
19159
19160
19161 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19162 PyObject *resultobj = 0;
19163 wxImage *arg1 = (wxImage *) 0 ;
19164 wxString *arg2 = 0 ;
19165 wxString result;
19166 void *argp1 = 0 ;
19167 int res1 = 0 ;
19168 bool temp2 = false ;
19169 PyObject * obj0 = 0 ;
19170 PyObject * obj1 = 0 ;
19171 char * kwnames[] = {
19172 (char *) "self",(char *) "name", NULL
19173 };
19174
19175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19177 if (!SWIG_IsOK(res1)) {
19178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19179 }
19180 arg1 = reinterpret_cast< wxImage * >(argp1);
19181 {
19182 arg2 = wxString_in_helper(obj1);
19183 if (arg2 == NULL) SWIG_fail;
19184 temp2 = true;
19185 }
19186 {
19187 PyThreadState* __tstate = wxPyBeginAllowThreads();
19188 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19189 wxPyEndAllowThreads(__tstate);
19190 if (PyErr_Occurred()) SWIG_fail;
19191 }
19192 {
19193 #if wxUSE_UNICODE
19194 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19195 #else
19196 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19197 #endif
19198 }
19199 {
19200 if (temp2)
19201 delete arg2;
19202 }
19203 return resultobj;
19204 fail:
19205 {
19206 if (temp2)
19207 delete arg2;
19208 }
19209 return NULL;
19210 }
19211
19212
19213 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19214 PyObject *resultobj = 0;
19215 wxImage *arg1 = (wxImage *) 0 ;
19216 wxString *arg2 = 0 ;
19217 int result;
19218 void *argp1 = 0 ;
19219 int res1 = 0 ;
19220 bool temp2 = false ;
19221 PyObject * obj0 = 0 ;
19222 PyObject * obj1 = 0 ;
19223 char * kwnames[] = {
19224 (char *) "self",(char *) "name", NULL
19225 };
19226
19227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19229 if (!SWIG_IsOK(res1)) {
19230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19231 }
19232 arg1 = reinterpret_cast< wxImage * >(argp1);
19233 {
19234 arg2 = wxString_in_helper(obj1);
19235 if (arg2 == NULL) SWIG_fail;
19236 temp2 = true;
19237 }
19238 {
19239 PyThreadState* __tstate = wxPyBeginAllowThreads();
19240 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19241 wxPyEndAllowThreads(__tstate);
19242 if (PyErr_Occurred()) SWIG_fail;
19243 }
19244 resultobj = SWIG_From_int(static_cast< int >(result));
19245 {
19246 if (temp2)
19247 delete arg2;
19248 }
19249 return resultobj;
19250 fail:
19251 {
19252 if (temp2)
19253 delete arg2;
19254 }
19255 return NULL;
19256 }
19257
19258
19259 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19260 PyObject *resultobj = 0;
19261 wxImage *arg1 = (wxImage *) 0 ;
19262 wxString *arg2 = 0 ;
19263 bool result;
19264 void *argp1 = 0 ;
19265 int res1 = 0 ;
19266 bool temp2 = false ;
19267 PyObject * obj0 = 0 ;
19268 PyObject * obj1 = 0 ;
19269 char * kwnames[] = {
19270 (char *) "self",(char *) "name", NULL
19271 };
19272
19273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19275 if (!SWIG_IsOK(res1)) {
19276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19277 }
19278 arg1 = reinterpret_cast< wxImage * >(argp1);
19279 {
19280 arg2 = wxString_in_helper(obj1);
19281 if (arg2 == NULL) SWIG_fail;
19282 temp2 = true;
19283 }
19284 {
19285 PyThreadState* __tstate = wxPyBeginAllowThreads();
19286 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19287 wxPyEndAllowThreads(__tstate);
19288 if (PyErr_Occurred()) SWIG_fail;
19289 }
19290 {
19291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19292 }
19293 {
19294 if (temp2)
19295 delete arg2;
19296 }
19297 return resultobj;
19298 fail:
19299 {
19300 if (temp2)
19301 delete arg2;
19302 }
19303 return NULL;
19304 }
19305
19306
19307 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19308 PyObject *resultobj = 0;
19309 wxImage *arg1 = (wxImage *) 0 ;
19310 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19311 unsigned long result;
19312 void *argp1 = 0 ;
19313 int res1 = 0 ;
19314 unsigned long val2 ;
19315 int ecode2 = 0 ;
19316 PyObject * obj0 = 0 ;
19317 PyObject * obj1 = 0 ;
19318 char * kwnames[] = {
19319 (char *) "self",(char *) "stopafter", NULL
19320 };
19321
19322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19324 if (!SWIG_IsOK(res1)) {
19325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19326 }
19327 arg1 = reinterpret_cast< wxImage * >(argp1);
19328 if (obj1) {
19329 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19330 if (!SWIG_IsOK(ecode2)) {
19331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19332 }
19333 arg2 = static_cast< unsigned long >(val2);
19334 }
19335 {
19336 PyThreadState* __tstate = wxPyBeginAllowThreads();
19337 result = (unsigned long)(arg1)->CountColours(arg2);
19338 wxPyEndAllowThreads(__tstate);
19339 if (PyErr_Occurred()) SWIG_fail;
19340 }
19341 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19342 return resultobj;
19343 fail:
19344 return NULL;
19345 }
19346
19347
19348 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19349 PyObject *resultobj = 0;
19350 wxImage *arg1 = (wxImage *) 0 ;
19351 wxImageHistogram *arg2 = 0 ;
19352 unsigned long result;
19353 void *argp1 = 0 ;
19354 int res1 = 0 ;
19355 void *argp2 = 0 ;
19356 int res2 = 0 ;
19357 PyObject * obj0 = 0 ;
19358 PyObject * obj1 = 0 ;
19359 char * kwnames[] = {
19360 (char *) "self",(char *) "h", NULL
19361 };
19362
19363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19365 if (!SWIG_IsOK(res1)) {
19366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19367 }
19368 arg1 = reinterpret_cast< wxImage * >(argp1);
19369 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19370 if (!SWIG_IsOK(res2)) {
19371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19372 }
19373 if (!argp2) {
19374 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19375 }
19376 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19377 {
19378 PyThreadState* __tstate = wxPyBeginAllowThreads();
19379 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19380 wxPyEndAllowThreads(__tstate);
19381 if (PyErr_Occurred()) SWIG_fail;
19382 }
19383 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19384 return resultobj;
19385 fail:
19386 return NULL;
19387 }
19388
19389
19390 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19391 PyObject *resultobj = 0;
19392 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19393 void *argp1 = 0 ;
19394 int res1 = 0 ;
19395 PyObject * obj0 = 0 ;
19396 char * kwnames[] = {
19397 (char *) "handler", NULL
19398 };
19399
19400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19402 if (!SWIG_IsOK(res1)) {
19403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19404 }
19405 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19406 {
19407 PyThreadState* __tstate = wxPyBeginAllowThreads();
19408 wxImage::AddHandler(arg1);
19409 wxPyEndAllowThreads(__tstate);
19410 if (PyErr_Occurred()) SWIG_fail;
19411 }
19412 resultobj = SWIG_Py_Void();
19413 return resultobj;
19414 fail:
19415 return NULL;
19416 }
19417
19418
19419 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19420 PyObject *resultobj = 0;
19421 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19422 void *argp1 = 0 ;
19423 int res1 = 0 ;
19424 PyObject * obj0 = 0 ;
19425 char * kwnames[] = {
19426 (char *) "handler", NULL
19427 };
19428
19429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19431 if (!SWIG_IsOK(res1)) {
19432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19433 }
19434 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19435 {
19436 PyThreadState* __tstate = wxPyBeginAllowThreads();
19437 wxImage::InsertHandler(arg1);
19438 wxPyEndAllowThreads(__tstate);
19439 if (PyErr_Occurred()) SWIG_fail;
19440 }
19441 resultobj = SWIG_Py_Void();
19442 return resultobj;
19443 fail:
19444 return NULL;
19445 }
19446
19447
19448 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19449 PyObject *resultobj = 0;
19450 wxString *arg1 = 0 ;
19451 bool result;
19452 bool temp1 = false ;
19453 PyObject * obj0 = 0 ;
19454 char * kwnames[] = {
19455 (char *) "name", NULL
19456 };
19457
19458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19459 {
19460 arg1 = wxString_in_helper(obj0);
19461 if (arg1 == NULL) SWIG_fail;
19462 temp1 = true;
19463 }
19464 {
19465 PyThreadState* __tstate = wxPyBeginAllowThreads();
19466 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19467 wxPyEndAllowThreads(__tstate);
19468 if (PyErr_Occurred()) SWIG_fail;
19469 }
19470 {
19471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19472 }
19473 {
19474 if (temp1)
19475 delete arg1;
19476 }
19477 return resultobj;
19478 fail:
19479 {
19480 if (temp1)
19481 delete arg1;
19482 }
19483 return NULL;
19484 }
19485
19486
19487 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19488 PyObject *resultobj = 0;
19489 PyObject *result = 0 ;
19490
19491 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19492 {
19493 PyThreadState* __tstate = wxPyBeginAllowThreads();
19494 result = (PyObject *)wxImage_GetHandlers();
19495 wxPyEndAllowThreads(__tstate);
19496 if (PyErr_Occurred()) SWIG_fail;
19497 }
19498 resultobj = result;
19499 return resultobj;
19500 fail:
19501 return NULL;
19502 }
19503
19504
19505 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19506 PyObject *resultobj = 0;
19507 wxString result;
19508
19509 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19510 {
19511 PyThreadState* __tstate = wxPyBeginAllowThreads();
19512 result = wxImage::GetImageExtWildcard();
19513 wxPyEndAllowThreads(__tstate);
19514 if (PyErr_Occurred()) SWIG_fail;
19515 }
19516 {
19517 #if wxUSE_UNICODE
19518 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19519 #else
19520 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19521 #endif
19522 }
19523 return resultobj;
19524 fail:
19525 return NULL;
19526 }
19527
19528
19529 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19530 PyObject *resultobj = 0;
19531 wxImage *arg1 = (wxImage *) 0 ;
19532 int arg2 = (int) -1 ;
19533 wxBitmap result;
19534 void *argp1 = 0 ;
19535 int res1 = 0 ;
19536 int val2 ;
19537 int ecode2 = 0 ;
19538 PyObject * obj0 = 0 ;
19539 PyObject * obj1 = 0 ;
19540 char * kwnames[] = {
19541 (char *) "self",(char *) "depth", NULL
19542 };
19543
19544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19546 if (!SWIG_IsOK(res1)) {
19547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19548 }
19549 arg1 = reinterpret_cast< wxImage * >(argp1);
19550 if (obj1) {
19551 ecode2 = SWIG_AsVal_int(obj1, &val2);
19552 if (!SWIG_IsOK(ecode2)) {
19553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19554 }
19555 arg2 = static_cast< int >(val2);
19556 }
19557 {
19558 if (!wxPyCheckForApp()) SWIG_fail;
19559 PyThreadState* __tstate = wxPyBeginAllowThreads();
19560 result = wxImage_ConvertToBitmap(arg1,arg2);
19561 wxPyEndAllowThreads(__tstate);
19562 if (PyErr_Occurred()) SWIG_fail;
19563 }
19564 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19565 return resultobj;
19566 fail:
19567 return NULL;
19568 }
19569
19570
19571 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19572 PyObject *resultobj = 0;
19573 wxImage *arg1 = (wxImage *) 0 ;
19574 byte arg2 ;
19575 byte arg3 ;
19576 byte arg4 ;
19577 wxBitmap result;
19578 void *argp1 = 0 ;
19579 int res1 = 0 ;
19580 unsigned char val2 ;
19581 int ecode2 = 0 ;
19582 unsigned char val3 ;
19583 int ecode3 = 0 ;
19584 unsigned char val4 ;
19585 int ecode4 = 0 ;
19586 PyObject * obj0 = 0 ;
19587 PyObject * obj1 = 0 ;
19588 PyObject * obj2 = 0 ;
19589 PyObject * obj3 = 0 ;
19590 char * kwnames[] = {
19591 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19592 };
19593
19594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19596 if (!SWIG_IsOK(res1)) {
19597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19598 }
19599 arg1 = reinterpret_cast< wxImage * >(argp1);
19600 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19601 if (!SWIG_IsOK(ecode2)) {
19602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19603 }
19604 arg2 = static_cast< byte >(val2);
19605 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19606 if (!SWIG_IsOK(ecode3)) {
19607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19608 }
19609 arg3 = static_cast< byte >(val3);
19610 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19611 if (!SWIG_IsOK(ecode4)) {
19612 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19613 }
19614 arg4 = static_cast< byte >(val4);
19615 {
19616 if (!wxPyCheckForApp()) SWIG_fail;
19617 PyThreadState* __tstate = wxPyBeginAllowThreads();
19618 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19619 wxPyEndAllowThreads(__tstate);
19620 if (PyErr_Occurred()) SWIG_fail;
19621 }
19622 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19623 return resultobj;
19624 fail:
19625 return NULL;
19626 }
19627
19628
19629 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19630 PyObject *resultobj = 0;
19631 wxImage *arg1 = (wxImage *) 0 ;
19632 double arg2 ;
19633 void *argp1 = 0 ;
19634 int res1 = 0 ;
19635 double val2 ;
19636 int ecode2 = 0 ;
19637 PyObject * obj0 = 0 ;
19638 PyObject * obj1 = 0 ;
19639 char * kwnames[] = {
19640 (char *) "self",(char *) "angle", NULL
19641 };
19642
19643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19645 if (!SWIG_IsOK(res1)) {
19646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19647 }
19648 arg1 = reinterpret_cast< wxImage * >(argp1);
19649 ecode2 = SWIG_AsVal_double(obj1, &val2);
19650 if (!SWIG_IsOK(ecode2)) {
19651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19652 }
19653 arg2 = static_cast< double >(val2);
19654 {
19655 PyThreadState* __tstate = wxPyBeginAllowThreads();
19656 (arg1)->RotateHue(arg2);
19657 wxPyEndAllowThreads(__tstate);
19658 if (PyErr_Occurred()) SWIG_fail;
19659 }
19660 resultobj = SWIG_Py_Void();
19661 return resultobj;
19662 fail:
19663 return NULL;
19664 }
19665
19666
19667 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19668 PyObject *resultobj = 0;
19669 wxImage_RGBValue arg1 ;
19670 wxImage_HSVValue result;
19671 void *argp1 ;
19672 int res1 = 0 ;
19673 PyObject * obj0 = 0 ;
19674 char * kwnames[] = {
19675 (char *) "rgb", NULL
19676 };
19677
19678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19679 {
19680 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19681 if (!SWIG_IsOK(res1)) {
19682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19683 }
19684 if (!argp1) {
19685 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19686 } else {
19687 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19688 arg1 = *temp;
19689 if (SWIG_IsNewObj(res1)) delete temp;
19690 }
19691 }
19692 {
19693 PyThreadState* __tstate = wxPyBeginAllowThreads();
19694 result = wxImage::RGBtoHSV(arg1);
19695 wxPyEndAllowThreads(__tstate);
19696 if (PyErr_Occurred()) SWIG_fail;
19697 }
19698 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19699 return resultobj;
19700 fail:
19701 return NULL;
19702 }
19703
19704
19705 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19706 PyObject *resultobj = 0;
19707 wxImage_HSVValue arg1 ;
19708 wxImage_RGBValue result;
19709 void *argp1 ;
19710 int res1 = 0 ;
19711 PyObject * obj0 = 0 ;
19712 char * kwnames[] = {
19713 (char *) "hsv", NULL
19714 };
19715
19716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19717 {
19718 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19719 if (!SWIG_IsOK(res1)) {
19720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19721 }
19722 if (!argp1) {
19723 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19724 } else {
19725 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19726 arg1 = *temp;
19727 if (SWIG_IsNewObj(res1)) delete temp;
19728 }
19729 }
19730 {
19731 PyThreadState* __tstate = wxPyBeginAllowThreads();
19732 result = wxImage::HSVtoRGB(arg1);
19733 wxPyEndAllowThreads(__tstate);
19734 if (PyErr_Occurred()) SWIG_fail;
19735 }
19736 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19737 return resultobj;
19738 fail:
19739 return NULL;
19740 }
19741
19742
19743 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19744 PyObject *obj;
19745 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19746 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19747 return SWIG_Py_Void();
19748 }
19749
19750 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19751 return SWIG_Python_InitShadowInstance(args);
19752 }
19753
19754 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19755 PyObject *resultobj = 0;
19756 int arg1 ;
19757 int arg2 ;
19758 buffer arg3 ;
19759 int arg4 ;
19760 buffer arg5 = (buffer) NULL ;
19761 int arg6 = (int) 0 ;
19762 wxImage *result = 0 ;
19763 int val1 ;
19764 int ecode1 = 0 ;
19765 int val2 ;
19766 int ecode2 = 0 ;
19767 Py_ssize_t temp3 ;
19768 Py_ssize_t temp5 ;
19769 PyObject * obj0 = 0 ;
19770 PyObject * obj1 = 0 ;
19771 PyObject * obj2 = 0 ;
19772 PyObject * obj3 = 0 ;
19773 char * kwnames[] = {
19774 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19775 };
19776
19777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19778 ecode1 = SWIG_AsVal_int(obj0, &val1);
19779 if (!SWIG_IsOK(ecode1)) {
19780 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19781 }
19782 arg1 = static_cast< int >(val1);
19783 ecode2 = SWIG_AsVal_int(obj1, &val2);
19784 if (!SWIG_IsOK(ecode2)) {
19785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19786 }
19787 arg2 = static_cast< int >(val2);
19788 {
19789 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19790 arg4 = (int)temp3;
19791 }
19792 if (obj3) {
19793 {
19794 if (obj3 != Py_None) {
19795 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19796 arg6 = (int)temp5;
19797 }
19798 }
19799 }
19800 {
19801 PyThreadState* __tstate = wxPyBeginAllowThreads();
19802 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19803 wxPyEndAllowThreads(__tstate);
19804 if (PyErr_Occurred()) SWIG_fail;
19805 }
19806 {
19807 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19808 }
19809 return resultobj;
19810 fail:
19811 return NULL;
19812 }
19813
19814
19815 SWIGINTERN int NullImage_set(PyObject *) {
19816 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19817 return 1;
19818 }
19819
19820
19821 SWIGINTERN PyObject *NullImage_get(void) {
19822 PyObject *pyobj = 0;
19823
19824 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19825 return pyobj;
19826 }
19827
19828
19829 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19830 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19831 return 1;
19832 }
19833
19834
19835 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19836 PyObject *pyobj = 0;
19837
19838 {
19839 #if wxUSE_UNICODE
19840 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19841 #else
19842 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19843 #endif
19844 }
19845 return pyobj;
19846 }
19847
19848
19849 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19850 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19851 return 1;
19852 }
19853
19854
19855 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19856 PyObject *pyobj = 0;
19857
19858 {
19859 #if wxUSE_UNICODE
19860 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19861 #else
19862 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19863 #endif
19864 }
19865 return pyobj;
19866 }
19867
19868
19869 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19870 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19871 return 1;
19872 }
19873
19874
19875 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19876 PyObject *pyobj = 0;
19877
19878 {
19879 #if wxUSE_UNICODE
19880 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19881 #else
19882 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19883 #endif
19884 }
19885 return pyobj;
19886 }
19887
19888
19889 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19890 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19891 return 1;
19892 }
19893
19894
19895 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19896 PyObject *pyobj = 0;
19897
19898 {
19899 #if wxUSE_UNICODE
19900 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19901 #else
19902 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19903 #endif
19904 }
19905 return pyobj;
19906 }
19907
19908
19909 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19910 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19911 return 1;
19912 }
19913
19914
19915 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19916 PyObject *pyobj = 0;
19917
19918 {
19919 #if wxUSE_UNICODE
19920 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19921 #else
19922 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19923 #endif
19924 }
19925 return pyobj;
19926 }
19927
19928
19929 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
19930 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
19931 return 1;
19932 }
19933
19934
19935 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
19936 PyObject *pyobj = 0;
19937
19938 {
19939 #if wxUSE_UNICODE
19940 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19941 #else
19942 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19943 #endif
19944 }
19945 return pyobj;
19946 }
19947
19948
19949 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
19950 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
19951 return 1;
19952 }
19953
19954
19955 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
19956 PyObject *pyobj = 0;
19957
19958 {
19959 #if wxUSE_UNICODE
19960 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19961 #else
19962 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19963 #endif
19964 }
19965 return pyobj;
19966 }
19967
19968
19969 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
19970 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
19971 return 1;
19972 }
19973
19974
19975 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
19976 PyObject *pyobj = 0;
19977
19978 {
19979 #if wxUSE_UNICODE
19980 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19981 #else
19982 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19983 #endif
19984 }
19985 return pyobj;
19986 }
19987
19988
19989 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
19990 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
19991 return 1;
19992 }
19993
19994
19995 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
19996 PyObject *pyobj = 0;
19997
19998 {
19999 #if wxUSE_UNICODE
20000 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20001 #else
20002 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20003 #endif
20004 }
20005 return pyobj;
20006 }
20007
20008
20009 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
20010 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
20011 return 1;
20012 }
20013
20014
20015 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20016 PyObject *pyobj = 0;
20017
20018 {
20019 #if wxUSE_UNICODE
20020 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20021 #else
20022 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20023 #endif
20024 }
20025 return pyobj;
20026 }
20027
20028
20029 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20030 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20031 return 1;
20032 }
20033
20034
20035 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20036 PyObject *pyobj = 0;
20037
20038 {
20039 #if wxUSE_UNICODE
20040 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20041 #else
20042 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20043 #endif
20044 }
20045 return pyobj;
20046 }
20047
20048
20049 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20050 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20051 return 1;
20052 }
20053
20054
20055 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20056 PyObject *pyobj = 0;
20057
20058 {
20059 #if wxUSE_UNICODE
20060 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20061 #else
20062 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20063 #endif
20064 }
20065 return pyobj;
20066 }
20067
20068
20069 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20070 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20071 return 1;
20072 }
20073
20074
20075 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20076 PyObject *pyobj = 0;
20077
20078 {
20079 #if wxUSE_UNICODE
20080 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20081 #else
20082 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20083 #endif
20084 }
20085 return pyobj;
20086 }
20087
20088
20089 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20090 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20091 return 1;
20092 }
20093
20094
20095 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20096 PyObject *pyobj = 0;
20097
20098 {
20099 #if wxUSE_UNICODE
20100 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20101 #else
20102 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20103 #endif
20104 }
20105 return pyobj;
20106 }
20107
20108
20109 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20110 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20111 return 1;
20112 }
20113
20114
20115 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20116 PyObject *pyobj = 0;
20117
20118 {
20119 #if wxUSE_UNICODE
20120 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20121 #else
20122 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20123 #endif
20124 }
20125 return pyobj;
20126 }
20127
20128
20129 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20130 PyObject *resultobj = 0;
20131 wxBMPHandler *result = 0 ;
20132
20133 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20134 {
20135 PyThreadState* __tstate = wxPyBeginAllowThreads();
20136 result = (wxBMPHandler *)new wxBMPHandler();
20137 wxPyEndAllowThreads(__tstate);
20138 if (PyErr_Occurred()) SWIG_fail;
20139 }
20140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20141 return resultobj;
20142 fail:
20143 return NULL;
20144 }
20145
20146
20147 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20148 PyObject *obj;
20149 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20150 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20151 return SWIG_Py_Void();
20152 }
20153
20154 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20155 return SWIG_Python_InitShadowInstance(args);
20156 }
20157
20158 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20159 PyObject *resultobj = 0;
20160 wxICOHandler *result = 0 ;
20161
20162 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20163 {
20164 PyThreadState* __tstate = wxPyBeginAllowThreads();
20165 result = (wxICOHandler *)new wxICOHandler();
20166 wxPyEndAllowThreads(__tstate);
20167 if (PyErr_Occurred()) SWIG_fail;
20168 }
20169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20170 return resultobj;
20171 fail:
20172 return NULL;
20173 }
20174
20175
20176 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20177 PyObject *obj;
20178 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20179 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20180 return SWIG_Py_Void();
20181 }
20182
20183 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20184 return SWIG_Python_InitShadowInstance(args);
20185 }
20186
20187 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20188 PyObject *resultobj = 0;
20189 wxCURHandler *result = 0 ;
20190
20191 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20192 {
20193 PyThreadState* __tstate = wxPyBeginAllowThreads();
20194 result = (wxCURHandler *)new wxCURHandler();
20195 wxPyEndAllowThreads(__tstate);
20196 if (PyErr_Occurred()) SWIG_fail;
20197 }
20198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20199 return resultobj;
20200 fail:
20201 return NULL;
20202 }
20203
20204
20205 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20206 PyObject *obj;
20207 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20208 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20209 return SWIG_Py_Void();
20210 }
20211
20212 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20213 return SWIG_Python_InitShadowInstance(args);
20214 }
20215
20216 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20217 PyObject *resultobj = 0;
20218 wxANIHandler *result = 0 ;
20219
20220 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20221 {
20222 PyThreadState* __tstate = wxPyBeginAllowThreads();
20223 result = (wxANIHandler *)new wxANIHandler();
20224 wxPyEndAllowThreads(__tstate);
20225 if (PyErr_Occurred()) SWIG_fail;
20226 }
20227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20228 return resultobj;
20229 fail:
20230 return NULL;
20231 }
20232
20233
20234 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20235 PyObject *obj;
20236 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20237 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20238 return SWIG_Py_Void();
20239 }
20240
20241 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20242 return SWIG_Python_InitShadowInstance(args);
20243 }
20244
20245 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20246 PyObject *resultobj = 0;
20247 wxPNGHandler *result = 0 ;
20248
20249 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20250 {
20251 PyThreadState* __tstate = wxPyBeginAllowThreads();
20252 result = (wxPNGHandler *)new wxPNGHandler();
20253 wxPyEndAllowThreads(__tstate);
20254 if (PyErr_Occurred()) SWIG_fail;
20255 }
20256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20257 return resultobj;
20258 fail:
20259 return NULL;
20260 }
20261
20262
20263 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20264 PyObject *obj;
20265 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20266 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20267 return SWIG_Py_Void();
20268 }
20269
20270 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20271 return SWIG_Python_InitShadowInstance(args);
20272 }
20273
20274 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20275 PyObject *resultobj = 0;
20276 wxGIFHandler *result = 0 ;
20277
20278 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20279 {
20280 PyThreadState* __tstate = wxPyBeginAllowThreads();
20281 result = (wxGIFHandler *)new wxGIFHandler();
20282 wxPyEndAllowThreads(__tstate);
20283 if (PyErr_Occurred()) SWIG_fail;
20284 }
20285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20286 return resultobj;
20287 fail:
20288 return NULL;
20289 }
20290
20291
20292 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20293 PyObject *obj;
20294 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20295 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20296 return SWIG_Py_Void();
20297 }
20298
20299 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20300 return SWIG_Python_InitShadowInstance(args);
20301 }
20302
20303 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20304 PyObject *resultobj = 0;
20305 wxPCXHandler *result = 0 ;
20306
20307 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20308 {
20309 PyThreadState* __tstate = wxPyBeginAllowThreads();
20310 result = (wxPCXHandler *)new wxPCXHandler();
20311 wxPyEndAllowThreads(__tstate);
20312 if (PyErr_Occurred()) SWIG_fail;
20313 }
20314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20315 return resultobj;
20316 fail:
20317 return NULL;
20318 }
20319
20320
20321 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20322 PyObject *obj;
20323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20324 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20325 return SWIG_Py_Void();
20326 }
20327
20328 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20329 return SWIG_Python_InitShadowInstance(args);
20330 }
20331
20332 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20333 PyObject *resultobj = 0;
20334 wxJPEGHandler *result = 0 ;
20335
20336 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20337 {
20338 PyThreadState* __tstate = wxPyBeginAllowThreads();
20339 result = (wxJPEGHandler *)new wxJPEGHandler();
20340 wxPyEndAllowThreads(__tstate);
20341 if (PyErr_Occurred()) SWIG_fail;
20342 }
20343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20344 return resultobj;
20345 fail:
20346 return NULL;
20347 }
20348
20349
20350 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20351 PyObject *obj;
20352 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20353 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20354 return SWIG_Py_Void();
20355 }
20356
20357 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20358 return SWIG_Python_InitShadowInstance(args);
20359 }
20360
20361 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20362 PyObject *resultobj = 0;
20363 wxPNMHandler *result = 0 ;
20364
20365 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20366 {
20367 PyThreadState* __tstate = wxPyBeginAllowThreads();
20368 result = (wxPNMHandler *)new wxPNMHandler();
20369 wxPyEndAllowThreads(__tstate);
20370 if (PyErr_Occurred()) SWIG_fail;
20371 }
20372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20373 return resultobj;
20374 fail:
20375 return NULL;
20376 }
20377
20378
20379 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20380 PyObject *obj;
20381 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20382 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20383 return SWIG_Py_Void();
20384 }
20385
20386 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20387 return SWIG_Python_InitShadowInstance(args);
20388 }
20389
20390 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20391 PyObject *resultobj = 0;
20392 wxXPMHandler *result = 0 ;
20393
20394 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20395 {
20396 PyThreadState* __tstate = wxPyBeginAllowThreads();
20397 result = (wxXPMHandler *)new wxXPMHandler();
20398 wxPyEndAllowThreads(__tstate);
20399 if (PyErr_Occurred()) SWIG_fail;
20400 }
20401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20402 return resultobj;
20403 fail:
20404 return NULL;
20405 }
20406
20407
20408 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20409 PyObject *obj;
20410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20411 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20412 return SWIG_Py_Void();
20413 }
20414
20415 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20416 return SWIG_Python_InitShadowInstance(args);
20417 }
20418
20419 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20420 PyObject *resultobj = 0;
20421 wxTIFFHandler *result = 0 ;
20422
20423 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20424 {
20425 PyThreadState* __tstate = wxPyBeginAllowThreads();
20426 result = (wxTIFFHandler *)new wxTIFFHandler();
20427 wxPyEndAllowThreads(__tstate);
20428 if (PyErr_Occurred()) SWIG_fail;
20429 }
20430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20431 return resultobj;
20432 fail:
20433 return NULL;
20434 }
20435
20436
20437 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20438 PyObject *obj;
20439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20440 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20441 return SWIG_Py_Void();
20442 }
20443
20444 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20445 return SWIG_Python_InitShadowInstance(args);
20446 }
20447
20448 SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20449 PyObject *resultobj = 0;
20450 wxTGAHandler *result = 0 ;
20451
20452 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
20453 {
20454 PyThreadState* __tstate = wxPyBeginAllowThreads();
20455 result = (wxTGAHandler *)new wxTGAHandler();
20456 wxPyEndAllowThreads(__tstate);
20457 if (PyErr_Occurred()) SWIG_fail;
20458 }
20459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
20460 return resultobj;
20461 fail:
20462 return NULL;
20463 }
20464
20465
20466 SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20467 PyObject *obj;
20468 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20469 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
20470 return SWIG_Py_Void();
20471 }
20472
20473 SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20474 return SWIG_Python_InitShadowInstance(args);
20475 }
20476
20477 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20478 PyObject *resultobj = 0;
20479 wxImage *arg1 = 0 ;
20480 wxImage *arg2 = 0 ;
20481 int arg3 = (int) 236 ;
20482 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20483 bool result;
20484 void *argp1 = 0 ;
20485 int res1 = 0 ;
20486 void *argp2 = 0 ;
20487 int res2 = 0 ;
20488 int val3 ;
20489 int ecode3 = 0 ;
20490 int val4 ;
20491 int ecode4 = 0 ;
20492 PyObject * obj0 = 0 ;
20493 PyObject * obj1 = 0 ;
20494 PyObject * obj2 = 0 ;
20495 PyObject * obj3 = 0 ;
20496 char * kwnames[] = {
20497 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20498 };
20499
20500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20501 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20502 if (!SWIG_IsOK(res1)) {
20503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20504 }
20505 if (!argp1) {
20506 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20507 }
20508 arg1 = reinterpret_cast< wxImage * >(argp1);
20509 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20510 if (!SWIG_IsOK(res2)) {
20511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20512 }
20513 if (!argp2) {
20514 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20515 }
20516 arg2 = reinterpret_cast< wxImage * >(argp2);
20517 if (obj2) {
20518 ecode3 = SWIG_AsVal_int(obj2, &val3);
20519 if (!SWIG_IsOK(ecode3)) {
20520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20521 }
20522 arg3 = static_cast< int >(val3);
20523 }
20524 if (obj3) {
20525 ecode4 = SWIG_AsVal_int(obj3, &val4);
20526 if (!SWIG_IsOK(ecode4)) {
20527 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20528 }
20529 arg4 = static_cast< int >(val4);
20530 }
20531 {
20532 PyThreadState* __tstate = wxPyBeginAllowThreads();
20533 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20534 wxPyEndAllowThreads(__tstate);
20535 if (PyErr_Occurred()) SWIG_fail;
20536 }
20537 {
20538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20539 }
20540 return resultobj;
20541 fail:
20542 return NULL;
20543 }
20544
20545
20546 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20547 PyObject *obj;
20548 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20549 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20550 return SWIG_Py_Void();
20551 }
20552
20553 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20554 PyObject *resultobj = 0;
20555 wxEvtHandler *result = 0 ;
20556
20557 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20558 {
20559 PyThreadState* __tstate = wxPyBeginAllowThreads();
20560 result = (wxEvtHandler *)new wxEvtHandler();
20561 wxPyEndAllowThreads(__tstate);
20562 if (PyErr_Occurred()) SWIG_fail;
20563 }
20564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20565 return resultobj;
20566 fail:
20567 return NULL;
20568 }
20569
20570
20571 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20572 PyObject *resultobj = 0;
20573 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20574 wxEvtHandler *result = 0 ;
20575 void *argp1 = 0 ;
20576 int res1 = 0 ;
20577 PyObject *swig_obj[1] ;
20578
20579 if (!args) SWIG_fail;
20580 swig_obj[0] = args;
20581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20582 if (!SWIG_IsOK(res1)) {
20583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20584 }
20585 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20586 {
20587 PyThreadState* __tstate = wxPyBeginAllowThreads();
20588 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20589 wxPyEndAllowThreads(__tstate);
20590 if (PyErr_Occurred()) SWIG_fail;
20591 }
20592 {
20593 resultobj = wxPyMake_wxObject(result, 0);
20594 }
20595 return resultobj;
20596 fail:
20597 return NULL;
20598 }
20599
20600
20601 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20602 PyObject *resultobj = 0;
20603 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20604 wxEvtHandler *result = 0 ;
20605 void *argp1 = 0 ;
20606 int res1 = 0 ;
20607 PyObject *swig_obj[1] ;
20608
20609 if (!args) SWIG_fail;
20610 swig_obj[0] = args;
20611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20612 if (!SWIG_IsOK(res1)) {
20613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20614 }
20615 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20616 {
20617 PyThreadState* __tstate = wxPyBeginAllowThreads();
20618 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20619 wxPyEndAllowThreads(__tstate);
20620 if (PyErr_Occurred()) SWIG_fail;
20621 }
20622 {
20623 resultobj = wxPyMake_wxObject(result, 0);
20624 }
20625 return resultobj;
20626 fail:
20627 return NULL;
20628 }
20629
20630
20631 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20632 PyObject *resultobj = 0;
20633 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20634 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20635 void *argp1 = 0 ;
20636 int res1 = 0 ;
20637 void *argp2 = 0 ;
20638 int res2 = 0 ;
20639 PyObject * obj0 = 0 ;
20640 PyObject * obj1 = 0 ;
20641 char * kwnames[] = {
20642 (char *) "self",(char *) "handler", NULL
20643 };
20644
20645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20647 if (!SWIG_IsOK(res1)) {
20648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20649 }
20650 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20651 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20652 if (!SWIG_IsOK(res2)) {
20653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20654 }
20655 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20656 {
20657 PyThreadState* __tstate = wxPyBeginAllowThreads();
20658 (arg1)->SetNextHandler(arg2);
20659 wxPyEndAllowThreads(__tstate);
20660 if (PyErr_Occurred()) SWIG_fail;
20661 }
20662 resultobj = SWIG_Py_Void();
20663 return resultobj;
20664 fail:
20665 return NULL;
20666 }
20667
20668
20669 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20670 PyObject *resultobj = 0;
20671 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20672 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20673 void *argp1 = 0 ;
20674 int res1 = 0 ;
20675 void *argp2 = 0 ;
20676 int res2 = 0 ;
20677 PyObject * obj0 = 0 ;
20678 PyObject * obj1 = 0 ;
20679 char * kwnames[] = {
20680 (char *) "self",(char *) "handler", NULL
20681 };
20682
20683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20685 if (!SWIG_IsOK(res1)) {
20686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20687 }
20688 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20689 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20690 if (!SWIG_IsOK(res2)) {
20691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20692 }
20693 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20694 {
20695 PyThreadState* __tstate = wxPyBeginAllowThreads();
20696 (arg1)->SetPreviousHandler(arg2);
20697 wxPyEndAllowThreads(__tstate);
20698 if (PyErr_Occurred()) SWIG_fail;
20699 }
20700 resultobj = SWIG_Py_Void();
20701 return resultobj;
20702 fail:
20703 return NULL;
20704 }
20705
20706
20707 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20708 PyObject *resultobj = 0;
20709 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20710 bool result;
20711 void *argp1 = 0 ;
20712 int res1 = 0 ;
20713 PyObject *swig_obj[1] ;
20714
20715 if (!args) SWIG_fail;
20716 swig_obj[0] = args;
20717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20718 if (!SWIG_IsOK(res1)) {
20719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20720 }
20721 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20722 {
20723 PyThreadState* __tstate = wxPyBeginAllowThreads();
20724 result = (bool)(arg1)->GetEvtHandlerEnabled();
20725 wxPyEndAllowThreads(__tstate);
20726 if (PyErr_Occurred()) SWIG_fail;
20727 }
20728 {
20729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20730 }
20731 return resultobj;
20732 fail:
20733 return NULL;
20734 }
20735
20736
20737 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20738 PyObject *resultobj = 0;
20739 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20740 bool arg2 ;
20741 void *argp1 = 0 ;
20742 int res1 = 0 ;
20743 bool val2 ;
20744 int ecode2 = 0 ;
20745 PyObject * obj0 = 0 ;
20746 PyObject * obj1 = 0 ;
20747 char * kwnames[] = {
20748 (char *) "self",(char *) "enabled", NULL
20749 };
20750
20751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20753 if (!SWIG_IsOK(res1)) {
20754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20755 }
20756 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20757 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20758 if (!SWIG_IsOK(ecode2)) {
20759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20760 }
20761 arg2 = static_cast< bool >(val2);
20762 {
20763 PyThreadState* __tstate = wxPyBeginAllowThreads();
20764 (arg1)->SetEvtHandlerEnabled(arg2);
20765 wxPyEndAllowThreads(__tstate);
20766 if (PyErr_Occurred()) SWIG_fail;
20767 }
20768 resultobj = SWIG_Py_Void();
20769 return resultobj;
20770 fail:
20771 return NULL;
20772 }
20773
20774
20775 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20776 PyObject *resultobj = 0;
20777 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20778 wxEvent *arg2 = 0 ;
20779 bool result;
20780 void *argp1 = 0 ;
20781 int res1 = 0 ;
20782 void *argp2 = 0 ;
20783 int res2 = 0 ;
20784 PyObject * obj0 = 0 ;
20785 PyObject * obj1 = 0 ;
20786 char * kwnames[] = {
20787 (char *) "self",(char *) "event", NULL
20788 };
20789
20790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20792 if (!SWIG_IsOK(res1)) {
20793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20794 }
20795 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20796 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20797 if (!SWIG_IsOK(res2)) {
20798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20799 }
20800 if (!argp2) {
20801 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20802 }
20803 arg2 = reinterpret_cast< wxEvent * >(argp2);
20804 {
20805 PyThreadState* __tstate = wxPyBeginAllowThreads();
20806 result = (bool)(arg1)->ProcessEvent(*arg2);
20807 wxPyEndAllowThreads(__tstate);
20808 if (PyErr_Occurred()) SWIG_fail;
20809 }
20810 {
20811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20812 }
20813 return resultobj;
20814 fail:
20815 return NULL;
20816 }
20817
20818
20819 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20820 PyObject *resultobj = 0;
20821 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20822 wxEvent *arg2 = 0 ;
20823 void *argp1 = 0 ;
20824 int res1 = 0 ;
20825 void *argp2 = 0 ;
20826 int res2 = 0 ;
20827 PyObject * obj0 = 0 ;
20828 PyObject * obj1 = 0 ;
20829 char * kwnames[] = {
20830 (char *) "self",(char *) "event", NULL
20831 };
20832
20833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20835 if (!SWIG_IsOK(res1)) {
20836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20837 }
20838 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20839 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20840 if (!SWIG_IsOK(res2)) {
20841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20842 }
20843 if (!argp2) {
20844 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20845 }
20846 arg2 = reinterpret_cast< wxEvent * >(argp2);
20847 {
20848 PyThreadState* __tstate = wxPyBeginAllowThreads();
20849 (arg1)->AddPendingEvent(*arg2);
20850 wxPyEndAllowThreads(__tstate);
20851 if (PyErr_Occurred()) SWIG_fail;
20852 }
20853 resultobj = SWIG_Py_Void();
20854 return resultobj;
20855 fail:
20856 return NULL;
20857 }
20858
20859
20860 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20861 PyObject *resultobj = 0;
20862 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20863 void *argp1 = 0 ;
20864 int res1 = 0 ;
20865 PyObject *swig_obj[1] ;
20866
20867 if (!args) SWIG_fail;
20868 swig_obj[0] = args;
20869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20870 if (!SWIG_IsOK(res1)) {
20871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20872 }
20873 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20874 {
20875 PyThreadState* __tstate = wxPyBeginAllowThreads();
20876 (arg1)->ProcessPendingEvents();
20877 wxPyEndAllowThreads(__tstate);
20878 if (PyErr_Occurred()) SWIG_fail;
20879 }
20880 resultobj = SWIG_Py_Void();
20881 return resultobj;
20882 fail:
20883 return NULL;
20884 }
20885
20886
20887 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20888 PyObject *resultobj = 0;
20889 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20890 int arg2 ;
20891 int arg3 ;
20892 int arg4 ;
20893 PyObject *arg5 = (PyObject *) 0 ;
20894 void *argp1 = 0 ;
20895 int res1 = 0 ;
20896 int val2 ;
20897 int ecode2 = 0 ;
20898 int val3 ;
20899 int ecode3 = 0 ;
20900 int val4 ;
20901 int ecode4 = 0 ;
20902 PyObject * obj0 = 0 ;
20903 PyObject * obj1 = 0 ;
20904 PyObject * obj2 = 0 ;
20905 PyObject * obj3 = 0 ;
20906 PyObject * obj4 = 0 ;
20907 char * kwnames[] = {
20908 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20909 };
20910
20911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20913 if (!SWIG_IsOK(res1)) {
20914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20915 }
20916 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20917 ecode2 = SWIG_AsVal_int(obj1, &val2);
20918 if (!SWIG_IsOK(ecode2)) {
20919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
20920 }
20921 arg2 = static_cast< int >(val2);
20922 ecode3 = SWIG_AsVal_int(obj2, &val3);
20923 if (!SWIG_IsOK(ecode3)) {
20924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
20925 }
20926 arg3 = static_cast< int >(val3);
20927 ecode4 = SWIG_AsVal_int(obj3, &val4);
20928 if (!SWIG_IsOK(ecode4)) {
20929 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
20930 }
20931 arg4 = static_cast< int >(val4);
20932 arg5 = obj4;
20933 {
20934 PyThreadState* __tstate = wxPyBeginAllowThreads();
20935 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
20936 wxPyEndAllowThreads(__tstate);
20937 if (PyErr_Occurred()) SWIG_fail;
20938 }
20939 resultobj = SWIG_Py_Void();
20940 return resultobj;
20941 fail:
20942 return NULL;
20943 }
20944
20945
20946 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20947 PyObject *resultobj = 0;
20948 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20949 int arg2 ;
20950 int arg3 = (int) -1 ;
20951 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
20952 bool result;
20953 void *argp1 = 0 ;
20954 int res1 = 0 ;
20955 int val2 ;
20956 int ecode2 = 0 ;
20957 int val3 ;
20958 int ecode3 = 0 ;
20959 int val4 ;
20960 int ecode4 = 0 ;
20961 PyObject * obj0 = 0 ;
20962 PyObject * obj1 = 0 ;
20963 PyObject * obj2 = 0 ;
20964 PyObject * obj3 = 0 ;
20965 char * kwnames[] = {
20966 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
20967 };
20968
20969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20971 if (!SWIG_IsOK(res1)) {
20972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20973 }
20974 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20975 ecode2 = SWIG_AsVal_int(obj1, &val2);
20976 if (!SWIG_IsOK(ecode2)) {
20977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
20978 }
20979 arg2 = static_cast< int >(val2);
20980 if (obj2) {
20981 ecode3 = SWIG_AsVal_int(obj2, &val3);
20982 if (!SWIG_IsOK(ecode3)) {
20983 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
20984 }
20985 arg3 = static_cast< int >(val3);
20986 }
20987 if (obj3) {
20988 ecode4 = SWIG_AsVal_int(obj3, &val4);
20989 if (!SWIG_IsOK(ecode4)) {
20990 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
20991 }
20992 arg4 = static_cast< wxEventType >(val4);
20993 }
20994 {
20995 PyThreadState* __tstate = wxPyBeginAllowThreads();
20996 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
20997 wxPyEndAllowThreads(__tstate);
20998 if (PyErr_Occurred()) SWIG_fail;
20999 }
21000 {
21001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21002 }
21003 return resultobj;
21004 fail:
21005 return NULL;
21006 }
21007
21008
21009 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21010 PyObject *resultobj = 0;
21011 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21012 PyObject *arg2 = (PyObject *) 0 ;
21013 bool arg3 = (bool) true ;
21014 void *argp1 = 0 ;
21015 int res1 = 0 ;
21016 bool val3 ;
21017 int ecode3 = 0 ;
21018 PyObject * obj0 = 0 ;
21019 PyObject * obj1 = 0 ;
21020 PyObject * obj2 = 0 ;
21021 char * kwnames[] = {
21022 (char *) "self",(char *) "_self",(char *) "incref", NULL
21023 };
21024
21025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21027 if (!SWIG_IsOK(res1)) {
21028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21029 }
21030 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21031 arg2 = obj1;
21032 if (obj2) {
21033 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21034 if (!SWIG_IsOK(ecode3)) {
21035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21036 }
21037 arg3 = static_cast< bool >(val3);
21038 }
21039 {
21040 PyThreadState* __tstate = wxPyBeginAllowThreads();
21041 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21042 wxPyEndAllowThreads(__tstate);
21043 if (PyErr_Occurred()) SWIG_fail;
21044 }
21045 resultobj = SWIG_Py_Void();
21046 return resultobj;
21047 fail:
21048 return NULL;
21049 }
21050
21051
21052 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21053 PyObject *obj;
21054 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21055 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21056 return SWIG_Py_Void();
21057 }
21058
21059 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21060 return SWIG_Python_InitShadowInstance(args);
21061 }
21062
21063 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21064 PyObject *resultobj = 0;
21065 wxEventType result;
21066
21067 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21068 {
21069 PyThreadState* __tstate = wxPyBeginAllowThreads();
21070 result = (wxEventType)wxNewEventType();
21071 wxPyEndAllowThreads(__tstate);
21072 if (PyErr_Occurred()) SWIG_fail;
21073 }
21074 resultobj = SWIG_From_int(static_cast< int >(result));
21075 return resultobj;
21076 fail:
21077 return NULL;
21078 }
21079
21080
21081 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21082 PyObject *resultobj = 0;
21083 wxEvent *arg1 = (wxEvent *) 0 ;
21084 void *argp1 = 0 ;
21085 int res1 = 0 ;
21086 PyObject *swig_obj[1] ;
21087
21088 if (!args) SWIG_fail;
21089 swig_obj[0] = args;
21090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21091 if (!SWIG_IsOK(res1)) {
21092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21093 }
21094 arg1 = reinterpret_cast< wxEvent * >(argp1);
21095 {
21096 PyThreadState* __tstate = wxPyBeginAllowThreads();
21097 delete arg1;
21098
21099 wxPyEndAllowThreads(__tstate);
21100 if (PyErr_Occurred()) SWIG_fail;
21101 }
21102 resultobj = SWIG_Py_Void();
21103 return resultobj;
21104 fail:
21105 return NULL;
21106 }
21107
21108
21109 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21110 PyObject *resultobj = 0;
21111 wxEvent *arg1 = (wxEvent *) 0 ;
21112 wxEventType arg2 ;
21113 void *argp1 = 0 ;
21114 int res1 = 0 ;
21115 int val2 ;
21116 int ecode2 = 0 ;
21117 PyObject * obj0 = 0 ;
21118 PyObject * obj1 = 0 ;
21119 char * kwnames[] = {
21120 (char *) "self",(char *) "typ", NULL
21121 };
21122
21123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21125 if (!SWIG_IsOK(res1)) {
21126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21127 }
21128 arg1 = reinterpret_cast< wxEvent * >(argp1);
21129 ecode2 = SWIG_AsVal_int(obj1, &val2);
21130 if (!SWIG_IsOK(ecode2)) {
21131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21132 }
21133 arg2 = static_cast< wxEventType >(val2);
21134 {
21135 PyThreadState* __tstate = wxPyBeginAllowThreads();
21136 (arg1)->SetEventType(arg2);
21137 wxPyEndAllowThreads(__tstate);
21138 if (PyErr_Occurred()) SWIG_fail;
21139 }
21140 resultobj = SWIG_Py_Void();
21141 return resultobj;
21142 fail:
21143 return NULL;
21144 }
21145
21146
21147 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21148 PyObject *resultobj = 0;
21149 wxEvent *arg1 = (wxEvent *) 0 ;
21150 wxEventType result;
21151 void *argp1 = 0 ;
21152 int res1 = 0 ;
21153 PyObject *swig_obj[1] ;
21154
21155 if (!args) SWIG_fail;
21156 swig_obj[0] = args;
21157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21158 if (!SWIG_IsOK(res1)) {
21159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21160 }
21161 arg1 = reinterpret_cast< wxEvent * >(argp1);
21162 {
21163 PyThreadState* __tstate = wxPyBeginAllowThreads();
21164 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21165 wxPyEndAllowThreads(__tstate);
21166 if (PyErr_Occurred()) SWIG_fail;
21167 }
21168 resultobj = SWIG_From_int(static_cast< int >(result));
21169 return resultobj;
21170 fail:
21171 return NULL;
21172 }
21173
21174
21175 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21176 PyObject *resultobj = 0;
21177 wxEvent *arg1 = (wxEvent *) 0 ;
21178 wxObject *result = 0 ;
21179 void *argp1 = 0 ;
21180 int res1 = 0 ;
21181 PyObject *swig_obj[1] ;
21182
21183 if (!args) SWIG_fail;
21184 swig_obj[0] = args;
21185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21186 if (!SWIG_IsOK(res1)) {
21187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21188 }
21189 arg1 = reinterpret_cast< wxEvent * >(argp1);
21190 {
21191 PyThreadState* __tstate = wxPyBeginAllowThreads();
21192 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21193 wxPyEndAllowThreads(__tstate);
21194 if (PyErr_Occurred()) SWIG_fail;
21195 }
21196 {
21197 resultobj = wxPyMake_wxObject(result, (bool)0);
21198 }
21199 return resultobj;
21200 fail:
21201 return NULL;
21202 }
21203
21204
21205 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21206 PyObject *resultobj = 0;
21207 wxEvent *arg1 = (wxEvent *) 0 ;
21208 wxObject *arg2 = (wxObject *) 0 ;
21209 void *argp1 = 0 ;
21210 int res1 = 0 ;
21211 void *argp2 = 0 ;
21212 int res2 = 0 ;
21213 PyObject * obj0 = 0 ;
21214 PyObject * obj1 = 0 ;
21215 char * kwnames[] = {
21216 (char *) "self",(char *) "obj", NULL
21217 };
21218
21219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21221 if (!SWIG_IsOK(res1)) {
21222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21223 }
21224 arg1 = reinterpret_cast< wxEvent * >(argp1);
21225 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21226 if (!SWIG_IsOK(res2)) {
21227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21228 }
21229 arg2 = reinterpret_cast< wxObject * >(argp2);
21230 {
21231 PyThreadState* __tstate = wxPyBeginAllowThreads();
21232 (arg1)->SetEventObject(arg2);
21233 wxPyEndAllowThreads(__tstate);
21234 if (PyErr_Occurred()) SWIG_fail;
21235 }
21236 resultobj = SWIG_Py_Void();
21237 return resultobj;
21238 fail:
21239 return NULL;
21240 }
21241
21242
21243 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21244 PyObject *resultobj = 0;
21245 wxEvent *arg1 = (wxEvent *) 0 ;
21246 long result;
21247 void *argp1 = 0 ;
21248 int res1 = 0 ;
21249 PyObject *swig_obj[1] ;
21250
21251 if (!args) SWIG_fail;
21252 swig_obj[0] = args;
21253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21254 if (!SWIG_IsOK(res1)) {
21255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21256 }
21257 arg1 = reinterpret_cast< wxEvent * >(argp1);
21258 {
21259 PyThreadState* __tstate = wxPyBeginAllowThreads();
21260 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21261 wxPyEndAllowThreads(__tstate);
21262 if (PyErr_Occurred()) SWIG_fail;
21263 }
21264 resultobj = SWIG_From_long(static_cast< long >(result));
21265 return resultobj;
21266 fail:
21267 return NULL;
21268 }
21269
21270
21271 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21272 PyObject *resultobj = 0;
21273 wxEvent *arg1 = (wxEvent *) 0 ;
21274 long arg2 = (long) 0 ;
21275 void *argp1 = 0 ;
21276 int res1 = 0 ;
21277 long val2 ;
21278 int ecode2 = 0 ;
21279 PyObject * obj0 = 0 ;
21280 PyObject * obj1 = 0 ;
21281 char * kwnames[] = {
21282 (char *) "self",(char *) "ts", NULL
21283 };
21284
21285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21287 if (!SWIG_IsOK(res1)) {
21288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21289 }
21290 arg1 = reinterpret_cast< wxEvent * >(argp1);
21291 if (obj1) {
21292 ecode2 = SWIG_AsVal_long(obj1, &val2);
21293 if (!SWIG_IsOK(ecode2)) {
21294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21295 }
21296 arg2 = static_cast< long >(val2);
21297 }
21298 {
21299 PyThreadState* __tstate = wxPyBeginAllowThreads();
21300 (arg1)->SetTimestamp(arg2);
21301 wxPyEndAllowThreads(__tstate);
21302 if (PyErr_Occurred()) SWIG_fail;
21303 }
21304 resultobj = SWIG_Py_Void();
21305 return resultobj;
21306 fail:
21307 return NULL;
21308 }
21309
21310
21311 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21312 PyObject *resultobj = 0;
21313 wxEvent *arg1 = (wxEvent *) 0 ;
21314 int result;
21315 void *argp1 = 0 ;
21316 int res1 = 0 ;
21317 PyObject *swig_obj[1] ;
21318
21319 if (!args) SWIG_fail;
21320 swig_obj[0] = args;
21321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21322 if (!SWIG_IsOK(res1)) {
21323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21324 }
21325 arg1 = reinterpret_cast< wxEvent * >(argp1);
21326 {
21327 PyThreadState* __tstate = wxPyBeginAllowThreads();
21328 result = (int)((wxEvent const *)arg1)->GetId();
21329 wxPyEndAllowThreads(__tstate);
21330 if (PyErr_Occurred()) SWIG_fail;
21331 }
21332 resultobj = SWIG_From_int(static_cast< int >(result));
21333 return resultobj;
21334 fail:
21335 return NULL;
21336 }
21337
21338
21339 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21340 PyObject *resultobj = 0;
21341 wxEvent *arg1 = (wxEvent *) 0 ;
21342 int arg2 ;
21343 void *argp1 = 0 ;
21344 int res1 = 0 ;
21345 int val2 ;
21346 int ecode2 = 0 ;
21347 PyObject * obj0 = 0 ;
21348 PyObject * obj1 = 0 ;
21349 char * kwnames[] = {
21350 (char *) "self",(char *) "Id", NULL
21351 };
21352
21353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21355 if (!SWIG_IsOK(res1)) {
21356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21357 }
21358 arg1 = reinterpret_cast< wxEvent * >(argp1);
21359 ecode2 = SWIG_AsVal_int(obj1, &val2);
21360 if (!SWIG_IsOK(ecode2)) {
21361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21362 }
21363 arg2 = static_cast< int >(val2);
21364 {
21365 PyThreadState* __tstate = wxPyBeginAllowThreads();
21366 (arg1)->SetId(arg2);
21367 wxPyEndAllowThreads(__tstate);
21368 if (PyErr_Occurred()) SWIG_fail;
21369 }
21370 resultobj = SWIG_Py_Void();
21371 return resultobj;
21372 fail:
21373 return NULL;
21374 }
21375
21376
21377 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21378 PyObject *resultobj = 0;
21379 wxEvent *arg1 = (wxEvent *) 0 ;
21380 bool result;
21381 void *argp1 = 0 ;
21382 int res1 = 0 ;
21383 PyObject *swig_obj[1] ;
21384
21385 if (!args) SWIG_fail;
21386 swig_obj[0] = args;
21387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21388 if (!SWIG_IsOK(res1)) {
21389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21390 }
21391 arg1 = reinterpret_cast< wxEvent * >(argp1);
21392 {
21393 PyThreadState* __tstate = wxPyBeginAllowThreads();
21394 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21395 wxPyEndAllowThreads(__tstate);
21396 if (PyErr_Occurred()) SWIG_fail;
21397 }
21398 {
21399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21400 }
21401 return resultobj;
21402 fail:
21403 return NULL;
21404 }
21405
21406
21407 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21408 PyObject *resultobj = 0;
21409 wxEvent *arg1 = (wxEvent *) 0 ;
21410 bool arg2 = (bool) true ;
21411 void *argp1 = 0 ;
21412 int res1 = 0 ;
21413 bool val2 ;
21414 int ecode2 = 0 ;
21415 PyObject * obj0 = 0 ;
21416 PyObject * obj1 = 0 ;
21417 char * kwnames[] = {
21418 (char *) "self",(char *) "skip", NULL
21419 };
21420
21421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21423 if (!SWIG_IsOK(res1)) {
21424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21425 }
21426 arg1 = reinterpret_cast< wxEvent * >(argp1);
21427 if (obj1) {
21428 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21429 if (!SWIG_IsOK(ecode2)) {
21430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21431 }
21432 arg2 = static_cast< bool >(val2);
21433 }
21434 {
21435 PyThreadState* __tstate = wxPyBeginAllowThreads();
21436 (arg1)->Skip(arg2);
21437 wxPyEndAllowThreads(__tstate);
21438 if (PyErr_Occurred()) SWIG_fail;
21439 }
21440 resultobj = SWIG_Py_Void();
21441 return resultobj;
21442 fail:
21443 return NULL;
21444 }
21445
21446
21447 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21448 PyObject *resultobj = 0;
21449 wxEvent *arg1 = (wxEvent *) 0 ;
21450 bool result;
21451 void *argp1 = 0 ;
21452 int res1 = 0 ;
21453 PyObject *swig_obj[1] ;
21454
21455 if (!args) SWIG_fail;
21456 swig_obj[0] = args;
21457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21458 if (!SWIG_IsOK(res1)) {
21459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21460 }
21461 arg1 = reinterpret_cast< wxEvent * >(argp1);
21462 {
21463 PyThreadState* __tstate = wxPyBeginAllowThreads();
21464 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21465 wxPyEndAllowThreads(__tstate);
21466 if (PyErr_Occurred()) SWIG_fail;
21467 }
21468 {
21469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21470 }
21471 return resultobj;
21472 fail:
21473 return NULL;
21474 }
21475
21476
21477 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21478 PyObject *resultobj = 0;
21479 wxEvent *arg1 = (wxEvent *) 0 ;
21480 bool result;
21481 void *argp1 = 0 ;
21482 int res1 = 0 ;
21483 PyObject *swig_obj[1] ;
21484
21485 if (!args) SWIG_fail;
21486 swig_obj[0] = args;
21487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21488 if (!SWIG_IsOK(res1)) {
21489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21490 }
21491 arg1 = reinterpret_cast< wxEvent * >(argp1);
21492 {
21493 PyThreadState* __tstate = wxPyBeginAllowThreads();
21494 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21495 wxPyEndAllowThreads(__tstate);
21496 if (PyErr_Occurred()) SWIG_fail;
21497 }
21498 {
21499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21500 }
21501 return resultobj;
21502 fail:
21503 return NULL;
21504 }
21505
21506
21507 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21508 PyObject *resultobj = 0;
21509 wxEvent *arg1 = (wxEvent *) 0 ;
21510 int result;
21511 void *argp1 = 0 ;
21512 int res1 = 0 ;
21513 PyObject *swig_obj[1] ;
21514
21515 if (!args) SWIG_fail;
21516 swig_obj[0] = args;
21517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21518 if (!SWIG_IsOK(res1)) {
21519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21520 }
21521 arg1 = reinterpret_cast< wxEvent * >(argp1);
21522 {
21523 PyThreadState* __tstate = wxPyBeginAllowThreads();
21524 result = (int)(arg1)->StopPropagation();
21525 wxPyEndAllowThreads(__tstate);
21526 if (PyErr_Occurred()) SWIG_fail;
21527 }
21528 resultobj = SWIG_From_int(static_cast< int >(result));
21529 return resultobj;
21530 fail:
21531 return NULL;
21532 }
21533
21534
21535 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21536 PyObject *resultobj = 0;
21537 wxEvent *arg1 = (wxEvent *) 0 ;
21538 int arg2 ;
21539 void *argp1 = 0 ;
21540 int res1 = 0 ;
21541 int val2 ;
21542 int ecode2 = 0 ;
21543 PyObject * obj0 = 0 ;
21544 PyObject * obj1 = 0 ;
21545 char * kwnames[] = {
21546 (char *) "self",(char *) "propagationLevel", NULL
21547 };
21548
21549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21551 if (!SWIG_IsOK(res1)) {
21552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21553 }
21554 arg1 = reinterpret_cast< wxEvent * >(argp1);
21555 ecode2 = SWIG_AsVal_int(obj1, &val2);
21556 if (!SWIG_IsOK(ecode2)) {
21557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21558 }
21559 arg2 = static_cast< int >(val2);
21560 {
21561 PyThreadState* __tstate = wxPyBeginAllowThreads();
21562 (arg1)->ResumePropagation(arg2);
21563 wxPyEndAllowThreads(__tstate);
21564 if (PyErr_Occurred()) SWIG_fail;
21565 }
21566 resultobj = SWIG_Py_Void();
21567 return resultobj;
21568 fail:
21569 return NULL;
21570 }
21571
21572
21573 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21574 PyObject *resultobj = 0;
21575 wxEvent *arg1 = (wxEvent *) 0 ;
21576 wxEvent *result = 0 ;
21577 void *argp1 = 0 ;
21578 int res1 = 0 ;
21579 PyObject *swig_obj[1] ;
21580
21581 if (!args) SWIG_fail;
21582 swig_obj[0] = args;
21583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21584 if (!SWIG_IsOK(res1)) {
21585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21586 }
21587 arg1 = reinterpret_cast< wxEvent * >(argp1);
21588 {
21589 PyThreadState* __tstate = wxPyBeginAllowThreads();
21590 result = (wxEvent *)(arg1)->Clone();
21591 wxPyEndAllowThreads(__tstate);
21592 if (PyErr_Occurred()) SWIG_fail;
21593 }
21594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21595 return resultobj;
21596 fail:
21597 return NULL;
21598 }
21599
21600
21601 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21602 PyObject *obj;
21603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21604 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21605 return SWIG_Py_Void();
21606 }
21607
21608 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21609 PyObject *resultobj = 0;
21610 wxEvent *arg1 = 0 ;
21611 wxPropagationDisabler *result = 0 ;
21612 void *argp1 = 0 ;
21613 int res1 = 0 ;
21614 PyObject * obj0 = 0 ;
21615 char * kwnames[] = {
21616 (char *) "event", NULL
21617 };
21618
21619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21620 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21621 if (!SWIG_IsOK(res1)) {
21622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21623 }
21624 if (!argp1) {
21625 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21626 }
21627 arg1 = reinterpret_cast< wxEvent * >(argp1);
21628 {
21629 PyThreadState* __tstate = wxPyBeginAllowThreads();
21630 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21631 wxPyEndAllowThreads(__tstate);
21632 if (PyErr_Occurred()) SWIG_fail;
21633 }
21634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21635 return resultobj;
21636 fail:
21637 return NULL;
21638 }
21639
21640
21641 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21642 PyObject *resultobj = 0;
21643 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21644 void *argp1 = 0 ;
21645 int res1 = 0 ;
21646 PyObject *swig_obj[1] ;
21647
21648 if (!args) SWIG_fail;
21649 swig_obj[0] = args;
21650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21651 if (!SWIG_IsOK(res1)) {
21652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21653 }
21654 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21655 {
21656 PyThreadState* __tstate = wxPyBeginAllowThreads();
21657 delete arg1;
21658
21659 wxPyEndAllowThreads(__tstate);
21660 if (PyErr_Occurred()) SWIG_fail;
21661 }
21662 resultobj = SWIG_Py_Void();
21663 return resultobj;
21664 fail:
21665 return NULL;
21666 }
21667
21668
21669 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21670 PyObject *obj;
21671 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21672 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21673 return SWIG_Py_Void();
21674 }
21675
21676 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21677 return SWIG_Python_InitShadowInstance(args);
21678 }
21679
21680 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21681 PyObject *resultobj = 0;
21682 wxEvent *arg1 = 0 ;
21683 wxPropagateOnce *result = 0 ;
21684 void *argp1 = 0 ;
21685 int res1 = 0 ;
21686 PyObject * obj0 = 0 ;
21687 char * kwnames[] = {
21688 (char *) "event", NULL
21689 };
21690
21691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21692 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21693 if (!SWIG_IsOK(res1)) {
21694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21695 }
21696 if (!argp1) {
21697 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21698 }
21699 arg1 = reinterpret_cast< wxEvent * >(argp1);
21700 {
21701 PyThreadState* __tstate = wxPyBeginAllowThreads();
21702 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21703 wxPyEndAllowThreads(__tstate);
21704 if (PyErr_Occurred()) SWIG_fail;
21705 }
21706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21707 return resultobj;
21708 fail:
21709 return NULL;
21710 }
21711
21712
21713 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21714 PyObject *resultobj = 0;
21715 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21716 void *argp1 = 0 ;
21717 int res1 = 0 ;
21718 PyObject *swig_obj[1] ;
21719
21720 if (!args) SWIG_fail;
21721 swig_obj[0] = args;
21722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21723 if (!SWIG_IsOK(res1)) {
21724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21725 }
21726 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21727 {
21728 PyThreadState* __tstate = wxPyBeginAllowThreads();
21729 delete arg1;
21730
21731 wxPyEndAllowThreads(__tstate);
21732 if (PyErr_Occurred()) SWIG_fail;
21733 }
21734 resultobj = SWIG_Py_Void();
21735 return resultobj;
21736 fail:
21737 return NULL;
21738 }
21739
21740
21741 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21742 PyObject *obj;
21743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21744 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21745 return SWIG_Py_Void();
21746 }
21747
21748 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21749 return SWIG_Python_InitShadowInstance(args);
21750 }
21751
21752 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21753 PyObject *resultobj = 0;
21754 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21755 int arg2 = (int) 0 ;
21756 wxCommandEvent *result = 0 ;
21757 int val1 ;
21758 int ecode1 = 0 ;
21759 int val2 ;
21760 int ecode2 = 0 ;
21761 PyObject * obj0 = 0 ;
21762 PyObject * obj1 = 0 ;
21763 char * kwnames[] = {
21764 (char *) "commandType",(char *) "winid", NULL
21765 };
21766
21767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21768 if (obj0) {
21769 ecode1 = SWIG_AsVal_int(obj0, &val1);
21770 if (!SWIG_IsOK(ecode1)) {
21771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21772 }
21773 arg1 = static_cast< wxEventType >(val1);
21774 }
21775 if (obj1) {
21776 ecode2 = SWIG_AsVal_int(obj1, &val2);
21777 if (!SWIG_IsOK(ecode2)) {
21778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21779 }
21780 arg2 = static_cast< int >(val2);
21781 }
21782 {
21783 PyThreadState* __tstate = wxPyBeginAllowThreads();
21784 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21785 wxPyEndAllowThreads(__tstate);
21786 if (PyErr_Occurred()) SWIG_fail;
21787 }
21788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21789 return resultobj;
21790 fail:
21791 return NULL;
21792 }
21793
21794
21795 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21796 PyObject *resultobj = 0;
21797 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21798 int result;
21799 void *argp1 = 0 ;
21800 int res1 = 0 ;
21801 PyObject *swig_obj[1] ;
21802
21803 if (!args) SWIG_fail;
21804 swig_obj[0] = args;
21805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21806 if (!SWIG_IsOK(res1)) {
21807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21808 }
21809 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21810 {
21811 PyThreadState* __tstate = wxPyBeginAllowThreads();
21812 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21813 wxPyEndAllowThreads(__tstate);
21814 if (PyErr_Occurred()) SWIG_fail;
21815 }
21816 resultobj = SWIG_From_int(static_cast< int >(result));
21817 return resultobj;
21818 fail:
21819 return NULL;
21820 }
21821
21822
21823 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21824 PyObject *resultobj = 0;
21825 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21826 wxString *arg2 = 0 ;
21827 void *argp1 = 0 ;
21828 int res1 = 0 ;
21829 bool temp2 = false ;
21830 PyObject * obj0 = 0 ;
21831 PyObject * obj1 = 0 ;
21832 char * kwnames[] = {
21833 (char *) "self",(char *) "s", NULL
21834 };
21835
21836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21838 if (!SWIG_IsOK(res1)) {
21839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21840 }
21841 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21842 {
21843 arg2 = wxString_in_helper(obj1);
21844 if (arg2 == NULL) SWIG_fail;
21845 temp2 = true;
21846 }
21847 {
21848 PyThreadState* __tstate = wxPyBeginAllowThreads();
21849 (arg1)->SetString((wxString const &)*arg2);
21850 wxPyEndAllowThreads(__tstate);
21851 if (PyErr_Occurred()) SWIG_fail;
21852 }
21853 resultobj = SWIG_Py_Void();
21854 {
21855 if (temp2)
21856 delete arg2;
21857 }
21858 return resultobj;
21859 fail:
21860 {
21861 if (temp2)
21862 delete arg2;
21863 }
21864 return NULL;
21865 }
21866
21867
21868 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21869 PyObject *resultobj = 0;
21870 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21871 wxString result;
21872 void *argp1 = 0 ;
21873 int res1 = 0 ;
21874 PyObject *swig_obj[1] ;
21875
21876 if (!args) SWIG_fail;
21877 swig_obj[0] = args;
21878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21879 if (!SWIG_IsOK(res1)) {
21880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21881 }
21882 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21883 {
21884 PyThreadState* __tstate = wxPyBeginAllowThreads();
21885 result = ((wxCommandEvent const *)arg1)->GetString();
21886 wxPyEndAllowThreads(__tstate);
21887 if (PyErr_Occurred()) SWIG_fail;
21888 }
21889 {
21890 #if wxUSE_UNICODE
21891 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21892 #else
21893 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21894 #endif
21895 }
21896 return resultobj;
21897 fail:
21898 return NULL;
21899 }
21900
21901
21902 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21903 PyObject *resultobj = 0;
21904 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21905 bool result;
21906 void *argp1 = 0 ;
21907 int res1 = 0 ;
21908 PyObject *swig_obj[1] ;
21909
21910 if (!args) SWIG_fail;
21911 swig_obj[0] = args;
21912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21913 if (!SWIG_IsOK(res1)) {
21914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21915 }
21916 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21917 {
21918 PyThreadState* __tstate = wxPyBeginAllowThreads();
21919 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
21920 wxPyEndAllowThreads(__tstate);
21921 if (PyErr_Occurred()) SWIG_fail;
21922 }
21923 {
21924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21925 }
21926 return resultobj;
21927 fail:
21928 return NULL;
21929 }
21930
21931
21932 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21933 PyObject *resultobj = 0;
21934 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21935 bool result;
21936 void *argp1 = 0 ;
21937 int res1 = 0 ;
21938 PyObject *swig_obj[1] ;
21939
21940 if (!args) SWIG_fail;
21941 swig_obj[0] = args;
21942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21943 if (!SWIG_IsOK(res1)) {
21944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21945 }
21946 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21947 {
21948 PyThreadState* __tstate = wxPyBeginAllowThreads();
21949 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
21950 wxPyEndAllowThreads(__tstate);
21951 if (PyErr_Occurred()) SWIG_fail;
21952 }
21953 {
21954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21955 }
21956 return resultobj;
21957 fail:
21958 return NULL;
21959 }
21960
21961
21962 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21963 PyObject *resultobj = 0;
21964 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21965 long arg2 ;
21966 void *argp1 = 0 ;
21967 int res1 = 0 ;
21968 long val2 ;
21969 int ecode2 = 0 ;
21970 PyObject * obj0 = 0 ;
21971 PyObject * obj1 = 0 ;
21972 char * kwnames[] = {
21973 (char *) "self",(char *) "extraLong", NULL
21974 };
21975
21976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
21977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21978 if (!SWIG_IsOK(res1)) {
21979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21980 }
21981 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21982 ecode2 = SWIG_AsVal_long(obj1, &val2);
21983 if (!SWIG_IsOK(ecode2)) {
21984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
21985 }
21986 arg2 = static_cast< long >(val2);
21987 {
21988 PyThreadState* __tstate = wxPyBeginAllowThreads();
21989 (arg1)->SetExtraLong(arg2);
21990 wxPyEndAllowThreads(__tstate);
21991 if (PyErr_Occurred()) SWIG_fail;
21992 }
21993 resultobj = SWIG_Py_Void();
21994 return resultobj;
21995 fail:
21996 return NULL;
21997 }
21998
21999
22000 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22001 PyObject *resultobj = 0;
22002 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22003 long result;
22004 void *argp1 = 0 ;
22005 int res1 = 0 ;
22006 PyObject *swig_obj[1] ;
22007
22008 if (!args) SWIG_fail;
22009 swig_obj[0] = args;
22010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22011 if (!SWIG_IsOK(res1)) {
22012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22013 }
22014 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22015 {
22016 PyThreadState* __tstate = wxPyBeginAllowThreads();
22017 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22018 wxPyEndAllowThreads(__tstate);
22019 if (PyErr_Occurred()) SWIG_fail;
22020 }
22021 resultobj = SWIG_From_long(static_cast< long >(result));
22022 return resultobj;
22023 fail:
22024 return NULL;
22025 }
22026
22027
22028 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22029 PyObject *resultobj = 0;
22030 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22031 int arg2 ;
22032 void *argp1 = 0 ;
22033 int res1 = 0 ;
22034 int val2 ;
22035 int ecode2 = 0 ;
22036 PyObject * obj0 = 0 ;
22037 PyObject * obj1 = 0 ;
22038 char * kwnames[] = {
22039 (char *) "self",(char *) "i", NULL
22040 };
22041
22042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22044 if (!SWIG_IsOK(res1)) {
22045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22046 }
22047 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22048 ecode2 = SWIG_AsVal_int(obj1, &val2);
22049 if (!SWIG_IsOK(ecode2)) {
22050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22051 }
22052 arg2 = static_cast< int >(val2);
22053 {
22054 PyThreadState* __tstate = wxPyBeginAllowThreads();
22055 (arg1)->SetInt(arg2);
22056 wxPyEndAllowThreads(__tstate);
22057 if (PyErr_Occurred()) SWIG_fail;
22058 }
22059 resultobj = SWIG_Py_Void();
22060 return resultobj;
22061 fail:
22062 return NULL;
22063 }
22064
22065
22066 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22067 PyObject *resultobj = 0;
22068 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22069 int result;
22070 void *argp1 = 0 ;
22071 int res1 = 0 ;
22072 PyObject *swig_obj[1] ;
22073
22074 if (!args) SWIG_fail;
22075 swig_obj[0] = args;
22076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22077 if (!SWIG_IsOK(res1)) {
22078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22079 }
22080 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22081 {
22082 PyThreadState* __tstate = wxPyBeginAllowThreads();
22083 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22084 wxPyEndAllowThreads(__tstate);
22085 if (PyErr_Occurred()) SWIG_fail;
22086 }
22087 resultobj = SWIG_From_int(static_cast< int >(result));
22088 return resultobj;
22089 fail:
22090 return NULL;
22091 }
22092
22093
22094 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22095 PyObject *resultobj = 0;
22096 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22097 PyObject *result = 0 ;
22098 void *argp1 = 0 ;
22099 int res1 = 0 ;
22100 PyObject *swig_obj[1] ;
22101
22102 if (!args) SWIG_fail;
22103 swig_obj[0] = args;
22104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22105 if (!SWIG_IsOK(res1)) {
22106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22107 }
22108 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22109 {
22110 PyThreadState* __tstate = wxPyBeginAllowThreads();
22111 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22112 wxPyEndAllowThreads(__tstate);
22113 if (PyErr_Occurred()) SWIG_fail;
22114 }
22115 resultobj = result;
22116 return resultobj;
22117 fail:
22118 return NULL;
22119 }
22120
22121
22122 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22123 PyObject *resultobj = 0;
22124 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22125 PyObject *arg2 = (PyObject *) 0 ;
22126 void *argp1 = 0 ;
22127 int res1 = 0 ;
22128 PyObject * obj0 = 0 ;
22129 PyObject * obj1 = 0 ;
22130 char * kwnames[] = {
22131 (char *) "self",(char *) "clientData", NULL
22132 };
22133
22134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22136 if (!SWIG_IsOK(res1)) {
22137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22138 }
22139 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22140 arg2 = obj1;
22141 {
22142 PyThreadState* __tstate = wxPyBeginAllowThreads();
22143 wxCommandEvent_SetClientData(arg1,arg2);
22144 wxPyEndAllowThreads(__tstate);
22145 if (PyErr_Occurred()) SWIG_fail;
22146 }
22147 resultobj = SWIG_Py_Void();
22148 return resultobj;
22149 fail:
22150 return NULL;
22151 }
22152
22153
22154 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22155 PyObject *resultobj = 0;
22156 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22157 wxEvent *result = 0 ;
22158 void *argp1 = 0 ;
22159 int res1 = 0 ;
22160 PyObject *swig_obj[1] ;
22161
22162 if (!args) SWIG_fail;
22163 swig_obj[0] = args;
22164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22165 if (!SWIG_IsOK(res1)) {
22166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22167 }
22168 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22169 {
22170 PyThreadState* __tstate = wxPyBeginAllowThreads();
22171 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22172 wxPyEndAllowThreads(__tstate);
22173 if (PyErr_Occurred()) SWIG_fail;
22174 }
22175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22176 return resultobj;
22177 fail:
22178 return NULL;
22179 }
22180
22181
22182 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22183 PyObject *obj;
22184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22185 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22186 return SWIG_Py_Void();
22187 }
22188
22189 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22190 return SWIG_Python_InitShadowInstance(args);
22191 }
22192
22193 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22194 PyObject *resultobj = 0;
22195 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22196 int arg2 = (int) 0 ;
22197 wxNotifyEvent *result = 0 ;
22198 int val1 ;
22199 int ecode1 = 0 ;
22200 int val2 ;
22201 int ecode2 = 0 ;
22202 PyObject * obj0 = 0 ;
22203 PyObject * obj1 = 0 ;
22204 char * kwnames[] = {
22205 (char *) "commandType",(char *) "winid", NULL
22206 };
22207
22208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22209 if (obj0) {
22210 ecode1 = SWIG_AsVal_int(obj0, &val1);
22211 if (!SWIG_IsOK(ecode1)) {
22212 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22213 }
22214 arg1 = static_cast< wxEventType >(val1);
22215 }
22216 if (obj1) {
22217 ecode2 = SWIG_AsVal_int(obj1, &val2);
22218 if (!SWIG_IsOK(ecode2)) {
22219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22220 }
22221 arg2 = static_cast< int >(val2);
22222 }
22223 {
22224 PyThreadState* __tstate = wxPyBeginAllowThreads();
22225 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22226 wxPyEndAllowThreads(__tstate);
22227 if (PyErr_Occurred()) SWIG_fail;
22228 }
22229 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22230 return resultobj;
22231 fail:
22232 return NULL;
22233 }
22234
22235
22236 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22237 PyObject *resultobj = 0;
22238 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22239 void *argp1 = 0 ;
22240 int res1 = 0 ;
22241 PyObject *swig_obj[1] ;
22242
22243 if (!args) SWIG_fail;
22244 swig_obj[0] = args;
22245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22246 if (!SWIG_IsOK(res1)) {
22247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22248 }
22249 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22250 {
22251 PyThreadState* __tstate = wxPyBeginAllowThreads();
22252 (arg1)->Veto();
22253 wxPyEndAllowThreads(__tstate);
22254 if (PyErr_Occurred()) SWIG_fail;
22255 }
22256 resultobj = SWIG_Py_Void();
22257 return resultobj;
22258 fail:
22259 return NULL;
22260 }
22261
22262
22263 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22264 PyObject *resultobj = 0;
22265 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22266 void *argp1 = 0 ;
22267 int res1 = 0 ;
22268 PyObject *swig_obj[1] ;
22269
22270 if (!args) SWIG_fail;
22271 swig_obj[0] = args;
22272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22273 if (!SWIG_IsOK(res1)) {
22274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22275 }
22276 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22277 {
22278 PyThreadState* __tstate = wxPyBeginAllowThreads();
22279 (arg1)->Allow();
22280 wxPyEndAllowThreads(__tstate);
22281 if (PyErr_Occurred()) SWIG_fail;
22282 }
22283 resultobj = SWIG_Py_Void();
22284 return resultobj;
22285 fail:
22286 return NULL;
22287 }
22288
22289
22290 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22291 PyObject *resultobj = 0;
22292 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22293 bool result;
22294 void *argp1 = 0 ;
22295 int res1 = 0 ;
22296 PyObject *swig_obj[1] ;
22297
22298 if (!args) SWIG_fail;
22299 swig_obj[0] = args;
22300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22301 if (!SWIG_IsOK(res1)) {
22302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22303 }
22304 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22305 {
22306 PyThreadState* __tstate = wxPyBeginAllowThreads();
22307 result = (bool)(arg1)->IsAllowed();
22308 wxPyEndAllowThreads(__tstate);
22309 if (PyErr_Occurred()) SWIG_fail;
22310 }
22311 {
22312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22313 }
22314 return resultobj;
22315 fail:
22316 return NULL;
22317 }
22318
22319
22320 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22321 PyObject *obj;
22322 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22323 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22324 return SWIG_Py_Void();
22325 }
22326
22327 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22328 return SWIG_Python_InitShadowInstance(args);
22329 }
22330
22331 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22332 PyObject *resultobj = 0;
22333 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22334 int arg2 = (int) 0 ;
22335 int arg3 = (int) 0 ;
22336 int arg4 = (int) 0 ;
22337 wxScrollEvent *result = 0 ;
22338 int val1 ;
22339 int ecode1 = 0 ;
22340 int val2 ;
22341 int ecode2 = 0 ;
22342 int val3 ;
22343 int ecode3 = 0 ;
22344 int val4 ;
22345 int ecode4 = 0 ;
22346 PyObject * obj0 = 0 ;
22347 PyObject * obj1 = 0 ;
22348 PyObject * obj2 = 0 ;
22349 PyObject * obj3 = 0 ;
22350 char * kwnames[] = {
22351 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22352 };
22353
22354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22355 if (obj0) {
22356 ecode1 = SWIG_AsVal_int(obj0, &val1);
22357 if (!SWIG_IsOK(ecode1)) {
22358 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22359 }
22360 arg1 = static_cast< wxEventType >(val1);
22361 }
22362 if (obj1) {
22363 ecode2 = SWIG_AsVal_int(obj1, &val2);
22364 if (!SWIG_IsOK(ecode2)) {
22365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22366 }
22367 arg2 = static_cast< int >(val2);
22368 }
22369 if (obj2) {
22370 ecode3 = SWIG_AsVal_int(obj2, &val3);
22371 if (!SWIG_IsOK(ecode3)) {
22372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22373 }
22374 arg3 = static_cast< int >(val3);
22375 }
22376 if (obj3) {
22377 ecode4 = SWIG_AsVal_int(obj3, &val4);
22378 if (!SWIG_IsOK(ecode4)) {
22379 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22380 }
22381 arg4 = static_cast< int >(val4);
22382 }
22383 {
22384 PyThreadState* __tstate = wxPyBeginAllowThreads();
22385 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22386 wxPyEndAllowThreads(__tstate);
22387 if (PyErr_Occurred()) SWIG_fail;
22388 }
22389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22390 return resultobj;
22391 fail:
22392 return NULL;
22393 }
22394
22395
22396 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22397 PyObject *resultobj = 0;
22398 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22399 int result;
22400 void *argp1 = 0 ;
22401 int res1 = 0 ;
22402 PyObject *swig_obj[1] ;
22403
22404 if (!args) SWIG_fail;
22405 swig_obj[0] = args;
22406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22407 if (!SWIG_IsOK(res1)) {
22408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22409 }
22410 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22411 {
22412 PyThreadState* __tstate = wxPyBeginAllowThreads();
22413 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22414 wxPyEndAllowThreads(__tstate);
22415 if (PyErr_Occurred()) SWIG_fail;
22416 }
22417 resultobj = SWIG_From_int(static_cast< int >(result));
22418 return resultobj;
22419 fail:
22420 return NULL;
22421 }
22422
22423
22424 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22425 PyObject *resultobj = 0;
22426 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22427 int result;
22428 void *argp1 = 0 ;
22429 int res1 = 0 ;
22430 PyObject *swig_obj[1] ;
22431
22432 if (!args) SWIG_fail;
22433 swig_obj[0] = args;
22434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22435 if (!SWIG_IsOK(res1)) {
22436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22437 }
22438 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22439 {
22440 PyThreadState* __tstate = wxPyBeginAllowThreads();
22441 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22442 wxPyEndAllowThreads(__tstate);
22443 if (PyErr_Occurred()) SWIG_fail;
22444 }
22445 resultobj = SWIG_From_int(static_cast< int >(result));
22446 return resultobj;
22447 fail:
22448 return NULL;
22449 }
22450
22451
22452 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22453 PyObject *resultobj = 0;
22454 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22455 int arg2 ;
22456 void *argp1 = 0 ;
22457 int res1 = 0 ;
22458 int val2 ;
22459 int ecode2 = 0 ;
22460 PyObject * obj0 = 0 ;
22461 PyObject * obj1 = 0 ;
22462 char * kwnames[] = {
22463 (char *) "self",(char *) "orient", NULL
22464 };
22465
22466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22468 if (!SWIG_IsOK(res1)) {
22469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22470 }
22471 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22472 ecode2 = SWIG_AsVal_int(obj1, &val2);
22473 if (!SWIG_IsOK(ecode2)) {
22474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22475 }
22476 arg2 = static_cast< int >(val2);
22477 {
22478 PyThreadState* __tstate = wxPyBeginAllowThreads();
22479 (arg1)->SetOrientation(arg2);
22480 wxPyEndAllowThreads(__tstate);
22481 if (PyErr_Occurred()) SWIG_fail;
22482 }
22483 resultobj = SWIG_Py_Void();
22484 return resultobj;
22485 fail:
22486 return NULL;
22487 }
22488
22489
22490 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22491 PyObject *resultobj = 0;
22492 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22493 int arg2 ;
22494 void *argp1 = 0 ;
22495 int res1 = 0 ;
22496 int val2 ;
22497 int ecode2 = 0 ;
22498 PyObject * obj0 = 0 ;
22499 PyObject * obj1 = 0 ;
22500 char * kwnames[] = {
22501 (char *) "self",(char *) "pos", NULL
22502 };
22503
22504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22506 if (!SWIG_IsOK(res1)) {
22507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22508 }
22509 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22510 ecode2 = SWIG_AsVal_int(obj1, &val2);
22511 if (!SWIG_IsOK(ecode2)) {
22512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22513 }
22514 arg2 = static_cast< int >(val2);
22515 {
22516 PyThreadState* __tstate = wxPyBeginAllowThreads();
22517 (arg1)->SetPosition(arg2);
22518 wxPyEndAllowThreads(__tstate);
22519 if (PyErr_Occurred()) SWIG_fail;
22520 }
22521 resultobj = SWIG_Py_Void();
22522 return resultobj;
22523 fail:
22524 return NULL;
22525 }
22526
22527
22528 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22529 PyObject *obj;
22530 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22531 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22532 return SWIG_Py_Void();
22533 }
22534
22535 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22536 return SWIG_Python_InitShadowInstance(args);
22537 }
22538
22539 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22540 PyObject *resultobj = 0;
22541 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22542 int arg2 = (int) 0 ;
22543 int arg3 = (int) 0 ;
22544 wxScrollWinEvent *result = 0 ;
22545 int val1 ;
22546 int ecode1 = 0 ;
22547 int val2 ;
22548 int ecode2 = 0 ;
22549 int val3 ;
22550 int ecode3 = 0 ;
22551 PyObject * obj0 = 0 ;
22552 PyObject * obj1 = 0 ;
22553 PyObject * obj2 = 0 ;
22554 char * kwnames[] = {
22555 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22556 };
22557
22558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22559 if (obj0) {
22560 ecode1 = SWIG_AsVal_int(obj0, &val1);
22561 if (!SWIG_IsOK(ecode1)) {
22562 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22563 }
22564 arg1 = static_cast< wxEventType >(val1);
22565 }
22566 if (obj1) {
22567 ecode2 = SWIG_AsVal_int(obj1, &val2);
22568 if (!SWIG_IsOK(ecode2)) {
22569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22570 }
22571 arg2 = static_cast< int >(val2);
22572 }
22573 if (obj2) {
22574 ecode3 = SWIG_AsVal_int(obj2, &val3);
22575 if (!SWIG_IsOK(ecode3)) {
22576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22577 }
22578 arg3 = static_cast< int >(val3);
22579 }
22580 {
22581 PyThreadState* __tstate = wxPyBeginAllowThreads();
22582 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22583 wxPyEndAllowThreads(__tstate);
22584 if (PyErr_Occurred()) SWIG_fail;
22585 }
22586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22587 return resultobj;
22588 fail:
22589 return NULL;
22590 }
22591
22592
22593 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22594 PyObject *resultobj = 0;
22595 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22596 int result;
22597 void *argp1 = 0 ;
22598 int res1 = 0 ;
22599 PyObject *swig_obj[1] ;
22600
22601 if (!args) SWIG_fail;
22602 swig_obj[0] = args;
22603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22604 if (!SWIG_IsOK(res1)) {
22605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22606 }
22607 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22608 {
22609 PyThreadState* __tstate = wxPyBeginAllowThreads();
22610 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22611 wxPyEndAllowThreads(__tstate);
22612 if (PyErr_Occurred()) SWIG_fail;
22613 }
22614 resultobj = SWIG_From_int(static_cast< int >(result));
22615 return resultobj;
22616 fail:
22617 return NULL;
22618 }
22619
22620
22621 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22622 PyObject *resultobj = 0;
22623 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22624 int result;
22625 void *argp1 = 0 ;
22626 int res1 = 0 ;
22627 PyObject *swig_obj[1] ;
22628
22629 if (!args) SWIG_fail;
22630 swig_obj[0] = args;
22631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22632 if (!SWIG_IsOK(res1)) {
22633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22634 }
22635 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22636 {
22637 PyThreadState* __tstate = wxPyBeginAllowThreads();
22638 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22639 wxPyEndAllowThreads(__tstate);
22640 if (PyErr_Occurred()) SWIG_fail;
22641 }
22642 resultobj = SWIG_From_int(static_cast< int >(result));
22643 return resultobj;
22644 fail:
22645 return NULL;
22646 }
22647
22648
22649 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22650 PyObject *resultobj = 0;
22651 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22652 int arg2 ;
22653 void *argp1 = 0 ;
22654 int res1 = 0 ;
22655 int val2 ;
22656 int ecode2 = 0 ;
22657 PyObject * obj0 = 0 ;
22658 PyObject * obj1 = 0 ;
22659 char * kwnames[] = {
22660 (char *) "self",(char *) "orient", NULL
22661 };
22662
22663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22665 if (!SWIG_IsOK(res1)) {
22666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22667 }
22668 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22669 ecode2 = SWIG_AsVal_int(obj1, &val2);
22670 if (!SWIG_IsOK(ecode2)) {
22671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22672 }
22673 arg2 = static_cast< int >(val2);
22674 {
22675 PyThreadState* __tstate = wxPyBeginAllowThreads();
22676 (arg1)->SetOrientation(arg2);
22677 wxPyEndAllowThreads(__tstate);
22678 if (PyErr_Occurred()) SWIG_fail;
22679 }
22680 resultobj = SWIG_Py_Void();
22681 return resultobj;
22682 fail:
22683 return NULL;
22684 }
22685
22686
22687 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22688 PyObject *resultobj = 0;
22689 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22690 int arg2 ;
22691 void *argp1 = 0 ;
22692 int res1 = 0 ;
22693 int val2 ;
22694 int ecode2 = 0 ;
22695 PyObject * obj0 = 0 ;
22696 PyObject * obj1 = 0 ;
22697 char * kwnames[] = {
22698 (char *) "self",(char *) "pos", NULL
22699 };
22700
22701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22703 if (!SWIG_IsOK(res1)) {
22704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22705 }
22706 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22707 ecode2 = SWIG_AsVal_int(obj1, &val2);
22708 if (!SWIG_IsOK(ecode2)) {
22709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22710 }
22711 arg2 = static_cast< int >(val2);
22712 {
22713 PyThreadState* __tstate = wxPyBeginAllowThreads();
22714 (arg1)->SetPosition(arg2);
22715 wxPyEndAllowThreads(__tstate);
22716 if (PyErr_Occurred()) SWIG_fail;
22717 }
22718 resultobj = SWIG_Py_Void();
22719 return resultobj;
22720 fail:
22721 return NULL;
22722 }
22723
22724
22725 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22726 PyObject *obj;
22727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22728 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22729 return SWIG_Py_Void();
22730 }
22731
22732 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22733 return SWIG_Python_InitShadowInstance(args);
22734 }
22735
22736 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22737 PyObject *resultobj = 0;
22738 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22739 wxMouseEvent *result = 0 ;
22740 int val1 ;
22741 int ecode1 = 0 ;
22742 PyObject * obj0 = 0 ;
22743 char * kwnames[] = {
22744 (char *) "mouseType", NULL
22745 };
22746
22747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22748 if (obj0) {
22749 ecode1 = SWIG_AsVal_int(obj0, &val1);
22750 if (!SWIG_IsOK(ecode1)) {
22751 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22752 }
22753 arg1 = static_cast< wxEventType >(val1);
22754 }
22755 {
22756 PyThreadState* __tstate = wxPyBeginAllowThreads();
22757 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22758 wxPyEndAllowThreads(__tstate);
22759 if (PyErr_Occurred()) SWIG_fail;
22760 }
22761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22762 return resultobj;
22763 fail:
22764 return NULL;
22765 }
22766
22767
22768 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22769 PyObject *resultobj = 0;
22770 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22771 bool result;
22772 void *argp1 = 0 ;
22773 int res1 = 0 ;
22774 PyObject *swig_obj[1] ;
22775
22776 if (!args) SWIG_fail;
22777 swig_obj[0] = args;
22778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22779 if (!SWIG_IsOK(res1)) {
22780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22781 }
22782 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22783 {
22784 PyThreadState* __tstate = wxPyBeginAllowThreads();
22785 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22786 wxPyEndAllowThreads(__tstate);
22787 if (PyErr_Occurred()) SWIG_fail;
22788 }
22789 {
22790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22791 }
22792 return resultobj;
22793 fail:
22794 return NULL;
22795 }
22796
22797
22798 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22799 PyObject *resultobj = 0;
22800 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22801 int arg2 = (int) wxMOUSE_BTN_ANY ;
22802 bool result;
22803 void *argp1 = 0 ;
22804 int res1 = 0 ;
22805 int val2 ;
22806 int ecode2 = 0 ;
22807 PyObject * obj0 = 0 ;
22808 PyObject * obj1 = 0 ;
22809 char * kwnames[] = {
22810 (char *) "self",(char *) "but", NULL
22811 };
22812
22813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22815 if (!SWIG_IsOK(res1)) {
22816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22817 }
22818 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22819 if (obj1) {
22820 ecode2 = SWIG_AsVal_int(obj1, &val2);
22821 if (!SWIG_IsOK(ecode2)) {
22822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22823 }
22824 arg2 = static_cast< int >(val2);
22825 }
22826 {
22827 PyThreadState* __tstate = wxPyBeginAllowThreads();
22828 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22829 wxPyEndAllowThreads(__tstate);
22830 if (PyErr_Occurred()) SWIG_fail;
22831 }
22832 {
22833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22834 }
22835 return resultobj;
22836 fail:
22837 return NULL;
22838 }
22839
22840
22841 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22842 PyObject *resultobj = 0;
22843 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22844 int arg2 = (int) wxMOUSE_BTN_ANY ;
22845 bool result;
22846 void *argp1 = 0 ;
22847 int res1 = 0 ;
22848 int val2 ;
22849 int ecode2 = 0 ;
22850 PyObject * obj0 = 0 ;
22851 PyObject * obj1 = 0 ;
22852 char * kwnames[] = {
22853 (char *) "self",(char *) "but", NULL
22854 };
22855
22856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22858 if (!SWIG_IsOK(res1)) {
22859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22860 }
22861 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22862 if (obj1) {
22863 ecode2 = SWIG_AsVal_int(obj1, &val2);
22864 if (!SWIG_IsOK(ecode2)) {
22865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22866 }
22867 arg2 = static_cast< int >(val2);
22868 }
22869 {
22870 PyThreadState* __tstate = wxPyBeginAllowThreads();
22871 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22872 wxPyEndAllowThreads(__tstate);
22873 if (PyErr_Occurred()) SWIG_fail;
22874 }
22875 {
22876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22877 }
22878 return resultobj;
22879 fail:
22880 return NULL;
22881 }
22882
22883
22884 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22885 PyObject *resultobj = 0;
22886 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22887 int arg2 = (int) wxMOUSE_BTN_ANY ;
22888 bool result;
22889 void *argp1 = 0 ;
22890 int res1 = 0 ;
22891 int val2 ;
22892 int ecode2 = 0 ;
22893 PyObject * obj0 = 0 ;
22894 PyObject * obj1 = 0 ;
22895 char * kwnames[] = {
22896 (char *) "self",(char *) "but", NULL
22897 };
22898
22899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22901 if (!SWIG_IsOK(res1)) {
22902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22903 }
22904 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22905 if (obj1) {
22906 ecode2 = SWIG_AsVal_int(obj1, &val2);
22907 if (!SWIG_IsOK(ecode2)) {
22908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22909 }
22910 arg2 = static_cast< int >(val2);
22911 }
22912 {
22913 PyThreadState* __tstate = wxPyBeginAllowThreads();
22914 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22915 wxPyEndAllowThreads(__tstate);
22916 if (PyErr_Occurred()) SWIG_fail;
22917 }
22918 {
22919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22920 }
22921 return resultobj;
22922 fail:
22923 return NULL;
22924 }
22925
22926
22927 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22928 PyObject *resultobj = 0;
22929 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22930 int arg2 ;
22931 bool result;
22932 void *argp1 = 0 ;
22933 int res1 = 0 ;
22934 int val2 ;
22935 int ecode2 = 0 ;
22936 PyObject * obj0 = 0 ;
22937 PyObject * obj1 = 0 ;
22938 char * kwnames[] = {
22939 (char *) "self",(char *) "button", NULL
22940 };
22941
22942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
22943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22944 if (!SWIG_IsOK(res1)) {
22945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22946 }
22947 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22948 ecode2 = SWIG_AsVal_int(obj1, &val2);
22949 if (!SWIG_IsOK(ecode2)) {
22950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
22951 }
22952 arg2 = static_cast< int >(val2);
22953 {
22954 PyThreadState* __tstate = wxPyBeginAllowThreads();
22955 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
22956 wxPyEndAllowThreads(__tstate);
22957 if (PyErr_Occurred()) SWIG_fail;
22958 }
22959 {
22960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22961 }
22962 return resultobj;
22963 fail:
22964 return NULL;
22965 }
22966
22967
22968 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22969 PyObject *resultobj = 0;
22970 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22971 int arg2 ;
22972 bool result;
22973 void *argp1 = 0 ;
22974 int res1 = 0 ;
22975 int val2 ;
22976 int ecode2 = 0 ;
22977 PyObject * obj0 = 0 ;
22978 PyObject * obj1 = 0 ;
22979 char * kwnames[] = {
22980 (char *) "self",(char *) "but", NULL
22981 };
22982
22983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
22984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22985 if (!SWIG_IsOK(res1)) {
22986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22987 }
22988 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22989 ecode2 = SWIG_AsVal_int(obj1, &val2);
22990 if (!SWIG_IsOK(ecode2)) {
22991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
22992 }
22993 arg2 = static_cast< int >(val2);
22994 {
22995 PyThreadState* __tstate = wxPyBeginAllowThreads();
22996 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
22997 wxPyEndAllowThreads(__tstate);
22998 if (PyErr_Occurred()) SWIG_fail;
22999 }
23000 {
23001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23002 }
23003 return resultobj;
23004 fail:
23005 return NULL;
23006 }
23007
23008
23009 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23010 PyObject *resultobj = 0;
23011 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23012 int result;
23013 void *argp1 = 0 ;
23014 int res1 = 0 ;
23015 PyObject *swig_obj[1] ;
23016
23017 if (!args) SWIG_fail;
23018 swig_obj[0] = args;
23019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23020 if (!SWIG_IsOK(res1)) {
23021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23022 }
23023 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23024 {
23025 PyThreadState* __tstate = wxPyBeginAllowThreads();
23026 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23027 wxPyEndAllowThreads(__tstate);
23028 if (PyErr_Occurred()) SWIG_fail;
23029 }
23030 resultobj = SWIG_From_int(static_cast< int >(result));
23031 return resultobj;
23032 fail:
23033 return NULL;
23034 }
23035
23036
23037 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23038 PyObject *resultobj = 0;
23039 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23040 bool result;
23041 void *argp1 = 0 ;
23042 int res1 = 0 ;
23043 PyObject *swig_obj[1] ;
23044
23045 if (!args) SWIG_fail;
23046 swig_obj[0] = args;
23047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23048 if (!SWIG_IsOK(res1)) {
23049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23050 }
23051 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23052 {
23053 PyThreadState* __tstate = wxPyBeginAllowThreads();
23054 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23055 wxPyEndAllowThreads(__tstate);
23056 if (PyErr_Occurred()) SWIG_fail;
23057 }
23058 {
23059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23060 }
23061 return resultobj;
23062 fail:
23063 return NULL;
23064 }
23065
23066
23067 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23068 PyObject *resultobj = 0;
23069 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23070 bool result;
23071 void *argp1 = 0 ;
23072 int res1 = 0 ;
23073 PyObject *swig_obj[1] ;
23074
23075 if (!args) SWIG_fail;
23076 swig_obj[0] = args;
23077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23078 if (!SWIG_IsOK(res1)) {
23079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23080 }
23081 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23082 {
23083 PyThreadState* __tstate = wxPyBeginAllowThreads();
23084 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23085 wxPyEndAllowThreads(__tstate);
23086 if (PyErr_Occurred()) SWIG_fail;
23087 }
23088 {
23089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23090 }
23091 return resultobj;
23092 fail:
23093 return NULL;
23094 }
23095
23096
23097 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23098 PyObject *resultobj = 0;
23099 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23100 bool result;
23101 void *argp1 = 0 ;
23102 int res1 = 0 ;
23103 PyObject *swig_obj[1] ;
23104
23105 if (!args) SWIG_fail;
23106 swig_obj[0] = args;
23107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23108 if (!SWIG_IsOK(res1)) {
23109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23110 }
23111 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23112 {
23113 PyThreadState* __tstate = wxPyBeginAllowThreads();
23114 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23115 wxPyEndAllowThreads(__tstate);
23116 if (PyErr_Occurred()) SWIG_fail;
23117 }
23118 {
23119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23120 }
23121 return resultobj;
23122 fail:
23123 return NULL;
23124 }
23125
23126
23127 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23128 PyObject *resultobj = 0;
23129 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23130 bool result;
23131 void *argp1 = 0 ;
23132 int res1 = 0 ;
23133 PyObject *swig_obj[1] ;
23134
23135 if (!args) SWIG_fail;
23136 swig_obj[0] = args;
23137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23138 if (!SWIG_IsOK(res1)) {
23139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23140 }
23141 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23142 {
23143 PyThreadState* __tstate = wxPyBeginAllowThreads();
23144 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23145 wxPyEndAllowThreads(__tstate);
23146 if (PyErr_Occurred()) SWIG_fail;
23147 }
23148 {
23149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23150 }
23151 return resultobj;
23152 fail:
23153 return NULL;
23154 }
23155
23156
23157 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23158 PyObject *resultobj = 0;
23159 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23160 bool result;
23161 void *argp1 = 0 ;
23162 int res1 = 0 ;
23163 PyObject *swig_obj[1] ;
23164
23165 if (!args) SWIG_fail;
23166 swig_obj[0] = args;
23167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23168 if (!SWIG_IsOK(res1)) {
23169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23170 }
23171 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23172 {
23173 PyThreadState* __tstate = wxPyBeginAllowThreads();
23174 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23175 wxPyEndAllowThreads(__tstate);
23176 if (PyErr_Occurred()) SWIG_fail;
23177 }
23178 {
23179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23180 }
23181 return resultobj;
23182 fail:
23183 return NULL;
23184 }
23185
23186
23187 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23188 PyObject *resultobj = 0;
23189 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23190 bool result;
23191 void *argp1 = 0 ;
23192 int res1 = 0 ;
23193 PyObject *swig_obj[1] ;
23194
23195 if (!args) SWIG_fail;
23196 swig_obj[0] = args;
23197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23198 if (!SWIG_IsOK(res1)) {
23199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23200 }
23201 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23202 {
23203 PyThreadState* __tstate = wxPyBeginAllowThreads();
23204 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23205 wxPyEndAllowThreads(__tstate);
23206 if (PyErr_Occurred()) SWIG_fail;
23207 }
23208 {
23209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23210 }
23211 return resultobj;
23212 fail:
23213 return NULL;
23214 }
23215
23216
23217 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23218 PyObject *resultobj = 0;
23219 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23220 bool result;
23221 void *argp1 = 0 ;
23222 int res1 = 0 ;
23223 PyObject *swig_obj[1] ;
23224
23225 if (!args) SWIG_fail;
23226 swig_obj[0] = args;
23227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23228 if (!SWIG_IsOK(res1)) {
23229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23230 }
23231 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23232 {
23233 PyThreadState* __tstate = wxPyBeginAllowThreads();
23234 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23235 wxPyEndAllowThreads(__tstate);
23236 if (PyErr_Occurred()) SWIG_fail;
23237 }
23238 {
23239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23240 }
23241 return resultobj;
23242 fail:
23243 return NULL;
23244 }
23245
23246
23247 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23248 PyObject *resultobj = 0;
23249 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23250 bool result;
23251 void *argp1 = 0 ;
23252 int res1 = 0 ;
23253 PyObject *swig_obj[1] ;
23254
23255 if (!args) SWIG_fail;
23256 swig_obj[0] = args;
23257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23258 if (!SWIG_IsOK(res1)) {
23259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23260 }
23261 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23262 {
23263 PyThreadState* __tstate = wxPyBeginAllowThreads();
23264 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23265 wxPyEndAllowThreads(__tstate);
23266 if (PyErr_Occurred()) SWIG_fail;
23267 }
23268 {
23269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23270 }
23271 return resultobj;
23272 fail:
23273 return NULL;
23274 }
23275
23276
23277 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23278 PyObject *resultobj = 0;
23279 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23280 bool result;
23281 void *argp1 = 0 ;
23282 int res1 = 0 ;
23283 PyObject *swig_obj[1] ;
23284
23285 if (!args) SWIG_fail;
23286 swig_obj[0] = args;
23287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23288 if (!SWIG_IsOK(res1)) {
23289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23290 }
23291 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23292 {
23293 PyThreadState* __tstate = wxPyBeginAllowThreads();
23294 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23295 wxPyEndAllowThreads(__tstate);
23296 if (PyErr_Occurred()) SWIG_fail;
23297 }
23298 {
23299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23300 }
23301 return resultobj;
23302 fail:
23303 return NULL;
23304 }
23305
23306
23307 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23308 PyObject *resultobj = 0;
23309 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23310 bool result;
23311 void *argp1 = 0 ;
23312 int res1 = 0 ;
23313 PyObject *swig_obj[1] ;
23314
23315 if (!args) SWIG_fail;
23316 swig_obj[0] = args;
23317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23318 if (!SWIG_IsOK(res1)) {
23319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23320 }
23321 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23322 {
23323 PyThreadState* __tstate = wxPyBeginAllowThreads();
23324 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23325 wxPyEndAllowThreads(__tstate);
23326 if (PyErr_Occurred()) SWIG_fail;
23327 }
23328 {
23329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23330 }
23331 return resultobj;
23332 fail:
23333 return NULL;
23334 }
23335
23336
23337 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23338 PyObject *resultobj = 0;
23339 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23340 bool result;
23341 void *argp1 = 0 ;
23342 int res1 = 0 ;
23343 PyObject *swig_obj[1] ;
23344
23345 if (!args) SWIG_fail;
23346 swig_obj[0] = args;
23347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23348 if (!SWIG_IsOK(res1)) {
23349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23350 }
23351 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23352 {
23353 PyThreadState* __tstate = wxPyBeginAllowThreads();
23354 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23355 wxPyEndAllowThreads(__tstate);
23356 if (PyErr_Occurred()) SWIG_fail;
23357 }
23358 {
23359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23360 }
23361 return resultobj;
23362 fail:
23363 return NULL;
23364 }
23365
23366
23367 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23368 PyObject *resultobj = 0;
23369 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23370 bool result;
23371 void *argp1 = 0 ;
23372 int res1 = 0 ;
23373 PyObject *swig_obj[1] ;
23374
23375 if (!args) SWIG_fail;
23376 swig_obj[0] = args;
23377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23378 if (!SWIG_IsOK(res1)) {
23379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23380 }
23381 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23382 {
23383 PyThreadState* __tstate = wxPyBeginAllowThreads();
23384 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23385 wxPyEndAllowThreads(__tstate);
23386 if (PyErr_Occurred()) SWIG_fail;
23387 }
23388 {
23389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23390 }
23391 return resultobj;
23392 fail:
23393 return NULL;
23394 }
23395
23396
23397 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23398 PyObject *resultobj = 0;
23399 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23400 bool result;
23401 void *argp1 = 0 ;
23402 int res1 = 0 ;
23403 PyObject *swig_obj[1] ;
23404
23405 if (!args) SWIG_fail;
23406 swig_obj[0] = args;
23407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23408 if (!SWIG_IsOK(res1)) {
23409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23410 }
23411 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23412 {
23413 PyThreadState* __tstate = wxPyBeginAllowThreads();
23414 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23415 wxPyEndAllowThreads(__tstate);
23416 if (PyErr_Occurred()) SWIG_fail;
23417 }
23418 {
23419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23420 }
23421 return resultobj;
23422 fail:
23423 return NULL;
23424 }
23425
23426
23427 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23428 PyObject *resultobj = 0;
23429 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23430 bool result;
23431 void *argp1 = 0 ;
23432 int res1 = 0 ;
23433 PyObject *swig_obj[1] ;
23434
23435 if (!args) SWIG_fail;
23436 swig_obj[0] = args;
23437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23438 if (!SWIG_IsOK(res1)) {
23439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23440 }
23441 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23442 {
23443 PyThreadState* __tstate = wxPyBeginAllowThreads();
23444 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23445 wxPyEndAllowThreads(__tstate);
23446 if (PyErr_Occurred()) SWIG_fail;
23447 }
23448 {
23449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23450 }
23451 return resultobj;
23452 fail:
23453 return NULL;
23454 }
23455
23456
23457 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23458 PyObject *resultobj = 0;
23459 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23460 bool result;
23461 void *argp1 = 0 ;
23462 int res1 = 0 ;
23463 PyObject *swig_obj[1] ;
23464
23465 if (!args) SWIG_fail;
23466 swig_obj[0] = args;
23467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23468 if (!SWIG_IsOK(res1)) {
23469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23470 }
23471 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23472 {
23473 PyThreadState* __tstate = wxPyBeginAllowThreads();
23474 result = (bool)(arg1)->LeftIsDown();
23475 wxPyEndAllowThreads(__tstate);
23476 if (PyErr_Occurred()) SWIG_fail;
23477 }
23478 {
23479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23480 }
23481 return resultobj;
23482 fail:
23483 return NULL;
23484 }
23485
23486
23487 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23488 PyObject *resultobj = 0;
23489 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23490 bool result;
23491 void *argp1 = 0 ;
23492 int res1 = 0 ;
23493 PyObject *swig_obj[1] ;
23494
23495 if (!args) SWIG_fail;
23496 swig_obj[0] = args;
23497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23498 if (!SWIG_IsOK(res1)) {
23499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23500 }
23501 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23502 {
23503 PyThreadState* __tstate = wxPyBeginAllowThreads();
23504 result = (bool)(arg1)->MiddleIsDown();
23505 wxPyEndAllowThreads(__tstate);
23506 if (PyErr_Occurred()) SWIG_fail;
23507 }
23508 {
23509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23510 }
23511 return resultobj;
23512 fail:
23513 return NULL;
23514 }
23515
23516
23517 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23518 PyObject *resultobj = 0;
23519 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23520 bool result;
23521 void *argp1 = 0 ;
23522 int res1 = 0 ;
23523 PyObject *swig_obj[1] ;
23524
23525 if (!args) SWIG_fail;
23526 swig_obj[0] = args;
23527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23528 if (!SWIG_IsOK(res1)) {
23529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23530 }
23531 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23532 {
23533 PyThreadState* __tstate = wxPyBeginAllowThreads();
23534 result = (bool)(arg1)->RightIsDown();
23535 wxPyEndAllowThreads(__tstate);
23536 if (PyErr_Occurred()) SWIG_fail;
23537 }
23538 {
23539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23540 }
23541 return resultobj;
23542 fail:
23543 return NULL;
23544 }
23545
23546
23547 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23548 PyObject *resultobj = 0;
23549 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23550 bool result;
23551 void *argp1 = 0 ;
23552 int res1 = 0 ;
23553 PyObject *swig_obj[1] ;
23554
23555 if (!args) SWIG_fail;
23556 swig_obj[0] = args;
23557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23558 if (!SWIG_IsOK(res1)) {
23559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23560 }
23561 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23562 {
23563 PyThreadState* __tstate = wxPyBeginAllowThreads();
23564 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23565 wxPyEndAllowThreads(__tstate);
23566 if (PyErr_Occurred()) SWIG_fail;
23567 }
23568 {
23569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23570 }
23571 return resultobj;
23572 fail:
23573 return NULL;
23574 }
23575
23576
23577 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23578 PyObject *resultobj = 0;
23579 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23580 bool result;
23581 void *argp1 = 0 ;
23582 int res1 = 0 ;
23583 PyObject *swig_obj[1] ;
23584
23585 if (!args) SWIG_fail;
23586 swig_obj[0] = args;
23587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23588 if (!SWIG_IsOK(res1)) {
23589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23590 }
23591 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23592 {
23593 PyThreadState* __tstate = wxPyBeginAllowThreads();
23594 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23595 wxPyEndAllowThreads(__tstate);
23596 if (PyErr_Occurred()) SWIG_fail;
23597 }
23598 {
23599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23600 }
23601 return resultobj;
23602 fail:
23603 return NULL;
23604 }
23605
23606
23607 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23608 PyObject *resultobj = 0;
23609 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23610 bool result;
23611 void *argp1 = 0 ;
23612 int res1 = 0 ;
23613 PyObject *swig_obj[1] ;
23614
23615 if (!args) SWIG_fail;
23616 swig_obj[0] = args;
23617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23618 if (!SWIG_IsOK(res1)) {
23619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23620 }
23621 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23622 {
23623 PyThreadState* __tstate = wxPyBeginAllowThreads();
23624 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23625 wxPyEndAllowThreads(__tstate);
23626 if (PyErr_Occurred()) SWIG_fail;
23627 }
23628 {
23629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23630 }
23631 return resultobj;
23632 fail:
23633 return NULL;
23634 }
23635
23636
23637 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23638 PyObject *resultobj = 0;
23639 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23640 bool result;
23641 void *argp1 = 0 ;
23642 int res1 = 0 ;
23643 PyObject *swig_obj[1] ;
23644
23645 if (!args) SWIG_fail;
23646 swig_obj[0] = args;
23647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23648 if (!SWIG_IsOK(res1)) {
23649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23650 }
23651 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23652 {
23653 PyThreadState* __tstate = wxPyBeginAllowThreads();
23654 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23655 wxPyEndAllowThreads(__tstate);
23656 if (PyErr_Occurred()) SWIG_fail;
23657 }
23658 {
23659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23660 }
23661 return resultobj;
23662 fail:
23663 return NULL;
23664 }
23665
23666
23667 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23668 PyObject *resultobj = 0;
23669 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23670 wxPoint result;
23671 void *argp1 = 0 ;
23672 int res1 = 0 ;
23673 PyObject *swig_obj[1] ;
23674
23675 if (!args) SWIG_fail;
23676 swig_obj[0] = args;
23677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23678 if (!SWIG_IsOK(res1)) {
23679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23680 }
23681 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23682 {
23683 PyThreadState* __tstate = wxPyBeginAllowThreads();
23684 result = (arg1)->GetPosition();
23685 wxPyEndAllowThreads(__tstate);
23686 if (PyErr_Occurred()) SWIG_fail;
23687 }
23688 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23689 return resultobj;
23690 fail:
23691 return NULL;
23692 }
23693
23694
23695 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23696 PyObject *resultobj = 0;
23697 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23698 long *arg2 = (long *) 0 ;
23699 long *arg3 = (long *) 0 ;
23700 void *argp1 = 0 ;
23701 int res1 = 0 ;
23702 long temp2 ;
23703 int res2 = SWIG_TMPOBJ ;
23704 long temp3 ;
23705 int res3 = SWIG_TMPOBJ ;
23706 PyObject *swig_obj[1] ;
23707
23708 arg2 = &temp2;
23709 arg3 = &temp3;
23710 if (!args) SWIG_fail;
23711 swig_obj[0] = args;
23712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23713 if (!SWIG_IsOK(res1)) {
23714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23715 }
23716 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23717 {
23718 PyThreadState* __tstate = wxPyBeginAllowThreads();
23719 (arg1)->GetPosition(arg2,arg3);
23720 wxPyEndAllowThreads(__tstate);
23721 if (PyErr_Occurred()) SWIG_fail;
23722 }
23723 resultobj = SWIG_Py_Void();
23724 if (SWIG_IsTmpObj(res2)) {
23725 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23726 } else {
23727 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23728 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23729 }
23730 if (SWIG_IsTmpObj(res3)) {
23731 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23732 } else {
23733 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23734 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23735 }
23736 return resultobj;
23737 fail:
23738 return NULL;
23739 }
23740
23741
23742 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23743 PyObject *resultobj = 0;
23744 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23745 wxDC *arg2 = 0 ;
23746 wxPoint result;
23747 void *argp1 = 0 ;
23748 int res1 = 0 ;
23749 void *argp2 = 0 ;
23750 int res2 = 0 ;
23751 PyObject * obj0 = 0 ;
23752 PyObject * obj1 = 0 ;
23753 char * kwnames[] = {
23754 (char *) "self",(char *) "dc", NULL
23755 };
23756
23757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23759 if (!SWIG_IsOK(res1)) {
23760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23761 }
23762 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23763 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23764 if (!SWIG_IsOK(res2)) {
23765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23766 }
23767 if (!argp2) {
23768 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23769 }
23770 arg2 = reinterpret_cast< wxDC * >(argp2);
23771 {
23772 PyThreadState* __tstate = wxPyBeginAllowThreads();
23773 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23774 wxPyEndAllowThreads(__tstate);
23775 if (PyErr_Occurred()) SWIG_fail;
23776 }
23777 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23778 return resultobj;
23779 fail:
23780 return NULL;
23781 }
23782
23783
23784 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23785 PyObject *resultobj = 0;
23786 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23787 int result;
23788 void *argp1 = 0 ;
23789 int res1 = 0 ;
23790 PyObject *swig_obj[1] ;
23791
23792 if (!args) SWIG_fail;
23793 swig_obj[0] = args;
23794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23795 if (!SWIG_IsOK(res1)) {
23796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23797 }
23798 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23799 {
23800 PyThreadState* __tstate = wxPyBeginAllowThreads();
23801 result = (int)((wxMouseEvent const *)arg1)->GetX();
23802 wxPyEndAllowThreads(__tstate);
23803 if (PyErr_Occurred()) SWIG_fail;
23804 }
23805 resultobj = SWIG_From_int(static_cast< int >(result));
23806 return resultobj;
23807 fail:
23808 return NULL;
23809 }
23810
23811
23812 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23813 PyObject *resultobj = 0;
23814 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23815 int result;
23816 void *argp1 = 0 ;
23817 int res1 = 0 ;
23818 PyObject *swig_obj[1] ;
23819
23820 if (!args) SWIG_fail;
23821 swig_obj[0] = args;
23822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23823 if (!SWIG_IsOK(res1)) {
23824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23825 }
23826 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23827 {
23828 PyThreadState* __tstate = wxPyBeginAllowThreads();
23829 result = (int)((wxMouseEvent const *)arg1)->GetY();
23830 wxPyEndAllowThreads(__tstate);
23831 if (PyErr_Occurred()) SWIG_fail;
23832 }
23833 resultobj = SWIG_From_int(static_cast< int >(result));
23834 return resultobj;
23835 fail:
23836 return NULL;
23837 }
23838
23839
23840 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23841 PyObject *resultobj = 0;
23842 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23843 int result;
23844 void *argp1 = 0 ;
23845 int res1 = 0 ;
23846 PyObject *swig_obj[1] ;
23847
23848 if (!args) SWIG_fail;
23849 swig_obj[0] = args;
23850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23851 if (!SWIG_IsOK(res1)) {
23852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23853 }
23854 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23855 {
23856 PyThreadState* __tstate = wxPyBeginAllowThreads();
23857 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23858 wxPyEndAllowThreads(__tstate);
23859 if (PyErr_Occurred()) SWIG_fail;
23860 }
23861 resultobj = SWIG_From_int(static_cast< int >(result));
23862 return resultobj;
23863 fail:
23864 return NULL;
23865 }
23866
23867
23868 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23869 PyObject *resultobj = 0;
23870 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23871 int result;
23872 void *argp1 = 0 ;
23873 int res1 = 0 ;
23874 PyObject *swig_obj[1] ;
23875
23876 if (!args) SWIG_fail;
23877 swig_obj[0] = args;
23878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23879 if (!SWIG_IsOK(res1)) {
23880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23881 }
23882 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23883 {
23884 PyThreadState* __tstate = wxPyBeginAllowThreads();
23885 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23886 wxPyEndAllowThreads(__tstate);
23887 if (PyErr_Occurred()) SWIG_fail;
23888 }
23889 resultobj = SWIG_From_int(static_cast< int >(result));
23890 return resultobj;
23891 fail:
23892 return NULL;
23893 }
23894
23895
23896 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23897 PyObject *resultobj = 0;
23898 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23899 int result;
23900 void *argp1 = 0 ;
23901 int res1 = 0 ;
23902 PyObject *swig_obj[1] ;
23903
23904 if (!args) SWIG_fail;
23905 swig_obj[0] = args;
23906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23907 if (!SWIG_IsOK(res1)) {
23908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23909 }
23910 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23911 {
23912 PyThreadState* __tstate = wxPyBeginAllowThreads();
23913 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
23914 wxPyEndAllowThreads(__tstate);
23915 if (PyErr_Occurred()) SWIG_fail;
23916 }
23917 resultobj = SWIG_From_int(static_cast< int >(result));
23918 return resultobj;
23919 fail:
23920 return NULL;
23921 }
23922
23923
23924 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23925 PyObject *resultobj = 0;
23926 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23927 bool result;
23928 void *argp1 = 0 ;
23929 int res1 = 0 ;
23930 PyObject *swig_obj[1] ;
23931
23932 if (!args) SWIG_fail;
23933 swig_obj[0] = args;
23934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23935 if (!SWIG_IsOK(res1)) {
23936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23937 }
23938 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23939 {
23940 PyThreadState* __tstate = wxPyBeginAllowThreads();
23941 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
23942 wxPyEndAllowThreads(__tstate);
23943 if (PyErr_Occurred()) SWIG_fail;
23944 }
23945 {
23946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23947 }
23948 return resultobj;
23949 fail:
23950 return NULL;
23951 }
23952
23953
23954 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23955 PyObject *resultobj = 0;
23956 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23957 int arg2 ;
23958 void *argp1 = 0 ;
23959 int res1 = 0 ;
23960 int val2 ;
23961 int ecode2 = 0 ;
23962 PyObject *swig_obj[2] ;
23963
23964 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23966 if (!SWIG_IsOK(res1)) {
23967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23968 }
23969 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23970 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23971 if (!SWIG_IsOK(ecode2)) {
23972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23973 }
23974 arg2 = static_cast< int >(val2);
23975 if (arg1) (arg1)->m_x = arg2;
23976
23977 resultobj = SWIG_Py_Void();
23978 return resultobj;
23979 fail:
23980 return NULL;
23981 }
23982
23983
23984 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23985 PyObject *resultobj = 0;
23986 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23987 int result;
23988 void *argp1 = 0 ;
23989 int res1 = 0 ;
23990 PyObject *swig_obj[1] ;
23991
23992 if (!args) SWIG_fail;
23993 swig_obj[0] = args;
23994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23995 if (!SWIG_IsOK(res1)) {
23996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23997 }
23998 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23999 result = (int) ((arg1)->m_x);
24000 resultobj = SWIG_From_int(static_cast< int >(result));
24001 return resultobj;
24002 fail:
24003 return NULL;
24004 }
24005
24006
24007 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24008 PyObject *resultobj = 0;
24009 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24010 int arg2 ;
24011 void *argp1 = 0 ;
24012 int res1 = 0 ;
24013 int val2 ;
24014 int ecode2 = 0 ;
24015 PyObject *swig_obj[2] ;
24016
24017 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24019 if (!SWIG_IsOK(res1)) {
24020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24021 }
24022 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24023 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24024 if (!SWIG_IsOK(ecode2)) {
24025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24026 }
24027 arg2 = static_cast< int >(val2);
24028 if (arg1) (arg1)->m_y = arg2;
24029
24030 resultobj = SWIG_Py_Void();
24031 return resultobj;
24032 fail:
24033 return NULL;
24034 }
24035
24036
24037 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24038 PyObject *resultobj = 0;
24039 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24040 int result;
24041 void *argp1 = 0 ;
24042 int res1 = 0 ;
24043 PyObject *swig_obj[1] ;
24044
24045 if (!args) SWIG_fail;
24046 swig_obj[0] = args;
24047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24048 if (!SWIG_IsOK(res1)) {
24049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24050 }
24051 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24052 result = (int) ((arg1)->m_y);
24053 resultobj = SWIG_From_int(static_cast< int >(result));
24054 return resultobj;
24055 fail:
24056 return NULL;
24057 }
24058
24059
24060 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24061 PyObject *resultobj = 0;
24062 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24063 bool arg2 ;
24064 void *argp1 = 0 ;
24065 int res1 = 0 ;
24066 bool val2 ;
24067 int ecode2 = 0 ;
24068 PyObject *swig_obj[2] ;
24069
24070 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24072 if (!SWIG_IsOK(res1)) {
24073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24074 }
24075 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24076 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24077 if (!SWIG_IsOK(ecode2)) {
24078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24079 }
24080 arg2 = static_cast< bool >(val2);
24081 if (arg1) (arg1)->m_leftDown = arg2;
24082
24083 resultobj = SWIG_Py_Void();
24084 return resultobj;
24085 fail:
24086 return NULL;
24087 }
24088
24089
24090 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24091 PyObject *resultobj = 0;
24092 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24093 bool result;
24094 void *argp1 = 0 ;
24095 int res1 = 0 ;
24096 PyObject *swig_obj[1] ;
24097
24098 if (!args) SWIG_fail;
24099 swig_obj[0] = args;
24100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24101 if (!SWIG_IsOK(res1)) {
24102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24103 }
24104 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24105 result = (bool) ((arg1)->m_leftDown);
24106 {
24107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24108 }
24109 return resultobj;
24110 fail:
24111 return NULL;
24112 }
24113
24114
24115 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24116 PyObject *resultobj = 0;
24117 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24118 bool arg2 ;
24119 void *argp1 = 0 ;
24120 int res1 = 0 ;
24121 bool val2 ;
24122 int ecode2 = 0 ;
24123 PyObject *swig_obj[2] ;
24124
24125 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24127 if (!SWIG_IsOK(res1)) {
24128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24129 }
24130 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24131 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24132 if (!SWIG_IsOK(ecode2)) {
24133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24134 }
24135 arg2 = static_cast< bool >(val2);
24136 if (arg1) (arg1)->m_middleDown = arg2;
24137
24138 resultobj = SWIG_Py_Void();
24139 return resultobj;
24140 fail:
24141 return NULL;
24142 }
24143
24144
24145 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24146 PyObject *resultobj = 0;
24147 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24148 bool result;
24149 void *argp1 = 0 ;
24150 int res1 = 0 ;
24151 PyObject *swig_obj[1] ;
24152
24153 if (!args) SWIG_fail;
24154 swig_obj[0] = args;
24155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24156 if (!SWIG_IsOK(res1)) {
24157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24158 }
24159 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24160 result = (bool) ((arg1)->m_middleDown);
24161 {
24162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24163 }
24164 return resultobj;
24165 fail:
24166 return NULL;
24167 }
24168
24169
24170 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24171 PyObject *resultobj = 0;
24172 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24173 bool arg2 ;
24174 void *argp1 = 0 ;
24175 int res1 = 0 ;
24176 bool val2 ;
24177 int ecode2 = 0 ;
24178 PyObject *swig_obj[2] ;
24179
24180 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24182 if (!SWIG_IsOK(res1)) {
24183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24184 }
24185 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24186 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24187 if (!SWIG_IsOK(ecode2)) {
24188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24189 }
24190 arg2 = static_cast< bool >(val2);
24191 if (arg1) (arg1)->m_rightDown = arg2;
24192
24193 resultobj = SWIG_Py_Void();
24194 return resultobj;
24195 fail:
24196 return NULL;
24197 }
24198
24199
24200 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24201 PyObject *resultobj = 0;
24202 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24203 bool result;
24204 void *argp1 = 0 ;
24205 int res1 = 0 ;
24206 PyObject *swig_obj[1] ;
24207
24208 if (!args) SWIG_fail;
24209 swig_obj[0] = args;
24210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24211 if (!SWIG_IsOK(res1)) {
24212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24213 }
24214 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24215 result = (bool) ((arg1)->m_rightDown);
24216 {
24217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24218 }
24219 return resultobj;
24220 fail:
24221 return NULL;
24222 }
24223
24224
24225 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24226 PyObject *resultobj = 0;
24227 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24228 bool arg2 ;
24229 void *argp1 = 0 ;
24230 int res1 = 0 ;
24231 bool val2 ;
24232 int ecode2 = 0 ;
24233 PyObject *swig_obj[2] ;
24234
24235 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24237 if (!SWIG_IsOK(res1)) {
24238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24239 }
24240 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24241 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24242 if (!SWIG_IsOK(ecode2)) {
24243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24244 }
24245 arg2 = static_cast< bool >(val2);
24246 if (arg1) (arg1)->m_controlDown = arg2;
24247
24248 resultobj = SWIG_Py_Void();
24249 return resultobj;
24250 fail:
24251 return NULL;
24252 }
24253
24254
24255 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24256 PyObject *resultobj = 0;
24257 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24258 bool result;
24259 void *argp1 = 0 ;
24260 int res1 = 0 ;
24261 PyObject *swig_obj[1] ;
24262
24263 if (!args) SWIG_fail;
24264 swig_obj[0] = args;
24265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24266 if (!SWIG_IsOK(res1)) {
24267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24268 }
24269 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24270 result = (bool) ((arg1)->m_controlDown);
24271 {
24272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24273 }
24274 return resultobj;
24275 fail:
24276 return NULL;
24277 }
24278
24279
24280 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24281 PyObject *resultobj = 0;
24282 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24283 bool arg2 ;
24284 void *argp1 = 0 ;
24285 int res1 = 0 ;
24286 bool val2 ;
24287 int ecode2 = 0 ;
24288 PyObject *swig_obj[2] ;
24289
24290 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24292 if (!SWIG_IsOK(res1)) {
24293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24294 }
24295 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24296 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24297 if (!SWIG_IsOK(ecode2)) {
24298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24299 }
24300 arg2 = static_cast< bool >(val2);
24301 if (arg1) (arg1)->m_shiftDown = arg2;
24302
24303 resultobj = SWIG_Py_Void();
24304 return resultobj;
24305 fail:
24306 return NULL;
24307 }
24308
24309
24310 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24311 PyObject *resultobj = 0;
24312 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24313 bool result;
24314 void *argp1 = 0 ;
24315 int res1 = 0 ;
24316 PyObject *swig_obj[1] ;
24317
24318 if (!args) SWIG_fail;
24319 swig_obj[0] = args;
24320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24321 if (!SWIG_IsOK(res1)) {
24322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24323 }
24324 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24325 result = (bool) ((arg1)->m_shiftDown);
24326 {
24327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24328 }
24329 return resultobj;
24330 fail:
24331 return NULL;
24332 }
24333
24334
24335 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24336 PyObject *resultobj = 0;
24337 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24338 bool arg2 ;
24339 void *argp1 = 0 ;
24340 int res1 = 0 ;
24341 bool val2 ;
24342 int ecode2 = 0 ;
24343 PyObject *swig_obj[2] ;
24344
24345 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24347 if (!SWIG_IsOK(res1)) {
24348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24349 }
24350 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24351 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24352 if (!SWIG_IsOK(ecode2)) {
24353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24354 }
24355 arg2 = static_cast< bool >(val2);
24356 if (arg1) (arg1)->m_altDown = arg2;
24357
24358 resultobj = SWIG_Py_Void();
24359 return resultobj;
24360 fail:
24361 return NULL;
24362 }
24363
24364
24365 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24366 PyObject *resultobj = 0;
24367 wxMouseEvent *arg1 = (wxMouseEvent *) 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_wxMouseEvent, 0 | 0 );
24376 if (!SWIG_IsOK(res1)) {
24377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24378 }
24379 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24380 result = (bool) ((arg1)->m_altDown);
24381 {
24382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24383 }
24384 return resultobj;
24385 fail:
24386 return NULL;
24387 }
24388
24389
24390 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24391 PyObject *resultobj = 0;
24392 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24393 bool arg2 ;
24394 void *argp1 = 0 ;
24395 int res1 = 0 ;
24396 bool val2 ;
24397 int ecode2 = 0 ;
24398 PyObject *swig_obj[2] ;
24399
24400 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24402 if (!SWIG_IsOK(res1)) {
24403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24404 }
24405 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24406 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24407 if (!SWIG_IsOK(ecode2)) {
24408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24409 }
24410 arg2 = static_cast< bool >(val2);
24411 if (arg1) (arg1)->m_metaDown = arg2;
24412
24413 resultobj = SWIG_Py_Void();
24414 return resultobj;
24415 fail:
24416 return NULL;
24417 }
24418
24419
24420 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24421 PyObject *resultobj = 0;
24422 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24423 bool result;
24424 void *argp1 = 0 ;
24425 int res1 = 0 ;
24426 PyObject *swig_obj[1] ;
24427
24428 if (!args) SWIG_fail;
24429 swig_obj[0] = args;
24430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24431 if (!SWIG_IsOK(res1)) {
24432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24433 }
24434 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24435 result = (bool) ((arg1)->m_metaDown);
24436 {
24437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24438 }
24439 return resultobj;
24440 fail:
24441 return NULL;
24442 }
24443
24444
24445 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24446 PyObject *resultobj = 0;
24447 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24448 int arg2 ;
24449 void *argp1 = 0 ;
24450 int res1 = 0 ;
24451 int val2 ;
24452 int ecode2 = 0 ;
24453 PyObject *swig_obj[2] ;
24454
24455 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24457 if (!SWIG_IsOK(res1)) {
24458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24459 }
24460 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24461 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24462 if (!SWIG_IsOK(ecode2)) {
24463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24464 }
24465 arg2 = static_cast< int >(val2);
24466 if (arg1) (arg1)->m_wheelRotation = arg2;
24467
24468 resultobj = SWIG_Py_Void();
24469 return resultobj;
24470 fail:
24471 return NULL;
24472 }
24473
24474
24475 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24476 PyObject *resultobj = 0;
24477 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24478 int result;
24479 void *argp1 = 0 ;
24480 int res1 = 0 ;
24481 PyObject *swig_obj[1] ;
24482
24483 if (!args) SWIG_fail;
24484 swig_obj[0] = args;
24485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24486 if (!SWIG_IsOK(res1)) {
24487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24488 }
24489 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24490 result = (int) ((arg1)->m_wheelRotation);
24491 resultobj = SWIG_From_int(static_cast< int >(result));
24492 return resultobj;
24493 fail:
24494 return NULL;
24495 }
24496
24497
24498 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24499 PyObject *resultobj = 0;
24500 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24501 int arg2 ;
24502 void *argp1 = 0 ;
24503 int res1 = 0 ;
24504 int val2 ;
24505 int ecode2 = 0 ;
24506 PyObject *swig_obj[2] ;
24507
24508 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24510 if (!SWIG_IsOK(res1)) {
24511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24512 }
24513 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24514 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24515 if (!SWIG_IsOK(ecode2)) {
24516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24517 }
24518 arg2 = static_cast< int >(val2);
24519 if (arg1) (arg1)->m_wheelDelta = arg2;
24520
24521 resultobj = SWIG_Py_Void();
24522 return resultobj;
24523 fail:
24524 return NULL;
24525 }
24526
24527
24528 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24529 PyObject *resultobj = 0;
24530 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24531 int result;
24532 void *argp1 = 0 ;
24533 int res1 = 0 ;
24534 PyObject *swig_obj[1] ;
24535
24536 if (!args) SWIG_fail;
24537 swig_obj[0] = args;
24538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24539 if (!SWIG_IsOK(res1)) {
24540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24541 }
24542 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24543 result = (int) ((arg1)->m_wheelDelta);
24544 resultobj = SWIG_From_int(static_cast< int >(result));
24545 return resultobj;
24546 fail:
24547 return NULL;
24548 }
24549
24550
24551 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24552 PyObject *resultobj = 0;
24553 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24554 int arg2 ;
24555 void *argp1 = 0 ;
24556 int res1 = 0 ;
24557 int val2 ;
24558 int ecode2 = 0 ;
24559 PyObject *swig_obj[2] ;
24560
24561 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24563 if (!SWIG_IsOK(res1)) {
24564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24565 }
24566 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24567 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24568 if (!SWIG_IsOK(ecode2)) {
24569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24570 }
24571 arg2 = static_cast< int >(val2);
24572 if (arg1) (arg1)->m_linesPerAction = arg2;
24573
24574 resultobj = SWIG_Py_Void();
24575 return resultobj;
24576 fail:
24577 return NULL;
24578 }
24579
24580
24581 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24582 PyObject *resultobj = 0;
24583 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24584 int result;
24585 void *argp1 = 0 ;
24586 int res1 = 0 ;
24587 PyObject *swig_obj[1] ;
24588
24589 if (!args) SWIG_fail;
24590 swig_obj[0] = args;
24591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24592 if (!SWIG_IsOK(res1)) {
24593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24594 }
24595 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24596 result = (int) ((arg1)->m_linesPerAction);
24597 resultobj = SWIG_From_int(static_cast< int >(result));
24598 return resultobj;
24599 fail:
24600 return NULL;
24601 }
24602
24603
24604 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24605 PyObject *obj;
24606 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24607 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24608 return SWIG_Py_Void();
24609 }
24610
24611 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24612 return SWIG_Python_InitShadowInstance(args);
24613 }
24614
24615 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24616 PyObject *resultobj = 0;
24617 int arg1 = (int) 0 ;
24618 int arg2 = (int) 0 ;
24619 wxSetCursorEvent *result = 0 ;
24620 int val1 ;
24621 int ecode1 = 0 ;
24622 int val2 ;
24623 int ecode2 = 0 ;
24624 PyObject * obj0 = 0 ;
24625 PyObject * obj1 = 0 ;
24626 char * kwnames[] = {
24627 (char *) "x",(char *) "y", NULL
24628 };
24629
24630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24631 if (obj0) {
24632 ecode1 = SWIG_AsVal_int(obj0, &val1);
24633 if (!SWIG_IsOK(ecode1)) {
24634 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24635 }
24636 arg1 = static_cast< int >(val1);
24637 }
24638 if (obj1) {
24639 ecode2 = SWIG_AsVal_int(obj1, &val2);
24640 if (!SWIG_IsOK(ecode2)) {
24641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24642 }
24643 arg2 = static_cast< int >(val2);
24644 }
24645 {
24646 PyThreadState* __tstate = wxPyBeginAllowThreads();
24647 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24648 wxPyEndAllowThreads(__tstate);
24649 if (PyErr_Occurred()) SWIG_fail;
24650 }
24651 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24652 return resultobj;
24653 fail:
24654 return NULL;
24655 }
24656
24657
24658 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24659 PyObject *resultobj = 0;
24660 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24661 int result;
24662 void *argp1 = 0 ;
24663 int res1 = 0 ;
24664 PyObject *swig_obj[1] ;
24665
24666 if (!args) SWIG_fail;
24667 swig_obj[0] = args;
24668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24669 if (!SWIG_IsOK(res1)) {
24670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24671 }
24672 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24673 {
24674 PyThreadState* __tstate = wxPyBeginAllowThreads();
24675 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24676 wxPyEndAllowThreads(__tstate);
24677 if (PyErr_Occurred()) SWIG_fail;
24678 }
24679 resultobj = SWIG_From_int(static_cast< int >(result));
24680 return resultobj;
24681 fail:
24682 return NULL;
24683 }
24684
24685
24686 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24687 PyObject *resultobj = 0;
24688 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24689 int result;
24690 void *argp1 = 0 ;
24691 int res1 = 0 ;
24692 PyObject *swig_obj[1] ;
24693
24694 if (!args) SWIG_fail;
24695 swig_obj[0] = args;
24696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24697 if (!SWIG_IsOK(res1)) {
24698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24699 }
24700 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24701 {
24702 PyThreadState* __tstate = wxPyBeginAllowThreads();
24703 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24704 wxPyEndAllowThreads(__tstate);
24705 if (PyErr_Occurred()) SWIG_fail;
24706 }
24707 resultobj = SWIG_From_int(static_cast< int >(result));
24708 return resultobj;
24709 fail:
24710 return NULL;
24711 }
24712
24713
24714 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24715 PyObject *resultobj = 0;
24716 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24717 wxCursor *arg2 = 0 ;
24718 void *argp1 = 0 ;
24719 int res1 = 0 ;
24720 void *argp2 = 0 ;
24721 int res2 = 0 ;
24722 PyObject * obj0 = 0 ;
24723 PyObject * obj1 = 0 ;
24724 char * kwnames[] = {
24725 (char *) "self",(char *) "cursor", NULL
24726 };
24727
24728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24730 if (!SWIG_IsOK(res1)) {
24731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24732 }
24733 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24734 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24735 if (!SWIG_IsOK(res2)) {
24736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24737 }
24738 if (!argp2) {
24739 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24740 }
24741 arg2 = reinterpret_cast< wxCursor * >(argp2);
24742 {
24743 PyThreadState* __tstate = wxPyBeginAllowThreads();
24744 (arg1)->SetCursor((wxCursor const &)*arg2);
24745 wxPyEndAllowThreads(__tstate);
24746 if (PyErr_Occurred()) SWIG_fail;
24747 }
24748 resultobj = SWIG_Py_Void();
24749 return resultobj;
24750 fail:
24751 return NULL;
24752 }
24753
24754
24755 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24756 PyObject *resultobj = 0;
24757 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24758 wxCursor *result = 0 ;
24759 void *argp1 = 0 ;
24760 int res1 = 0 ;
24761 PyObject *swig_obj[1] ;
24762
24763 if (!args) SWIG_fail;
24764 swig_obj[0] = args;
24765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24766 if (!SWIG_IsOK(res1)) {
24767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24768 }
24769 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24770 {
24771 PyThreadState* __tstate = wxPyBeginAllowThreads();
24772 {
24773 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24774 result = (wxCursor *) &_result_ref;
24775 }
24776 wxPyEndAllowThreads(__tstate);
24777 if (PyErr_Occurred()) SWIG_fail;
24778 }
24779 {
24780 wxCursor* resultptr = new wxCursor(*result);
24781 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24782 }
24783 return resultobj;
24784 fail:
24785 return NULL;
24786 }
24787
24788
24789 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24790 PyObject *resultobj = 0;
24791 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24792 bool result;
24793 void *argp1 = 0 ;
24794 int res1 = 0 ;
24795 PyObject *swig_obj[1] ;
24796
24797 if (!args) SWIG_fail;
24798 swig_obj[0] = args;
24799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24800 if (!SWIG_IsOK(res1)) {
24801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24802 }
24803 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24804 {
24805 PyThreadState* __tstate = wxPyBeginAllowThreads();
24806 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24807 wxPyEndAllowThreads(__tstate);
24808 if (PyErr_Occurred()) SWIG_fail;
24809 }
24810 {
24811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24812 }
24813 return resultobj;
24814 fail:
24815 return NULL;
24816 }
24817
24818
24819 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24820 PyObject *obj;
24821 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24822 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24823 return SWIG_Py_Void();
24824 }
24825
24826 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24827 return SWIG_Python_InitShadowInstance(args);
24828 }
24829
24830 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24831 PyObject *resultobj = 0;
24832 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24833 wxKeyEvent *result = 0 ;
24834 int val1 ;
24835 int ecode1 = 0 ;
24836 PyObject * obj0 = 0 ;
24837 char * kwnames[] = {
24838 (char *) "eventType", NULL
24839 };
24840
24841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24842 if (obj0) {
24843 ecode1 = SWIG_AsVal_int(obj0, &val1);
24844 if (!SWIG_IsOK(ecode1)) {
24845 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24846 }
24847 arg1 = static_cast< wxEventType >(val1);
24848 }
24849 {
24850 PyThreadState* __tstate = wxPyBeginAllowThreads();
24851 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24852 wxPyEndAllowThreads(__tstate);
24853 if (PyErr_Occurred()) SWIG_fail;
24854 }
24855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24856 return resultobj;
24857 fail:
24858 return NULL;
24859 }
24860
24861
24862 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24863 PyObject *resultobj = 0;
24864 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24865 int result;
24866 void *argp1 = 0 ;
24867 int res1 = 0 ;
24868 PyObject *swig_obj[1] ;
24869
24870 if (!args) SWIG_fail;
24871 swig_obj[0] = args;
24872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24873 if (!SWIG_IsOK(res1)) {
24874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24875 }
24876 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24877 {
24878 PyThreadState* __tstate = wxPyBeginAllowThreads();
24879 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24880 wxPyEndAllowThreads(__tstate);
24881 if (PyErr_Occurred()) SWIG_fail;
24882 }
24883 resultobj = SWIG_From_int(static_cast< int >(result));
24884 return resultobj;
24885 fail:
24886 return NULL;
24887 }
24888
24889
24890 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24891 PyObject *resultobj = 0;
24892 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24893 bool result;
24894 void *argp1 = 0 ;
24895 int res1 = 0 ;
24896 PyObject *swig_obj[1] ;
24897
24898 if (!args) SWIG_fail;
24899 swig_obj[0] = args;
24900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24901 if (!SWIG_IsOK(res1)) {
24902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24903 }
24904 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24905 {
24906 PyThreadState* __tstate = wxPyBeginAllowThreads();
24907 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
24908 wxPyEndAllowThreads(__tstate);
24909 if (PyErr_Occurred()) SWIG_fail;
24910 }
24911 {
24912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24913 }
24914 return resultobj;
24915 fail:
24916 return NULL;
24917 }
24918
24919
24920 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24921 PyObject *resultobj = 0;
24922 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24923 bool result;
24924 void *argp1 = 0 ;
24925 int res1 = 0 ;
24926 PyObject *swig_obj[1] ;
24927
24928 if (!args) SWIG_fail;
24929 swig_obj[0] = args;
24930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24931 if (!SWIG_IsOK(res1)) {
24932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24933 }
24934 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24935 {
24936 PyThreadState* __tstate = wxPyBeginAllowThreads();
24937 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
24938 wxPyEndAllowThreads(__tstate);
24939 if (PyErr_Occurred()) SWIG_fail;
24940 }
24941 {
24942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24943 }
24944 return resultobj;
24945 fail:
24946 return NULL;
24947 }
24948
24949
24950 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24951 PyObject *resultobj = 0;
24952 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24953 bool result;
24954 void *argp1 = 0 ;
24955 int res1 = 0 ;
24956 PyObject *swig_obj[1] ;
24957
24958 if (!args) SWIG_fail;
24959 swig_obj[0] = args;
24960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24961 if (!SWIG_IsOK(res1)) {
24962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24963 }
24964 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24965 {
24966 PyThreadState* __tstate = wxPyBeginAllowThreads();
24967 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
24968 wxPyEndAllowThreads(__tstate);
24969 if (PyErr_Occurred()) SWIG_fail;
24970 }
24971 {
24972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24973 }
24974 return resultobj;
24975 fail:
24976 return NULL;
24977 }
24978
24979
24980 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24981 PyObject *resultobj = 0;
24982 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24983 bool result;
24984 void *argp1 = 0 ;
24985 int res1 = 0 ;
24986 PyObject *swig_obj[1] ;
24987
24988 if (!args) SWIG_fail;
24989 swig_obj[0] = args;
24990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24991 if (!SWIG_IsOK(res1)) {
24992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24993 }
24994 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24995 {
24996 PyThreadState* __tstate = wxPyBeginAllowThreads();
24997 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
24998 wxPyEndAllowThreads(__tstate);
24999 if (PyErr_Occurred()) SWIG_fail;
25000 }
25001 {
25002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25003 }
25004 return resultobj;
25005 fail:
25006 return NULL;
25007 }
25008
25009
25010 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25011 PyObject *resultobj = 0;
25012 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25013 bool result;
25014 void *argp1 = 0 ;
25015 int res1 = 0 ;
25016 PyObject *swig_obj[1] ;
25017
25018 if (!args) SWIG_fail;
25019 swig_obj[0] = args;
25020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25021 if (!SWIG_IsOK(res1)) {
25022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25023 }
25024 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25025 {
25026 PyThreadState* __tstate = wxPyBeginAllowThreads();
25027 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25028 wxPyEndAllowThreads(__tstate);
25029 if (PyErr_Occurred()) SWIG_fail;
25030 }
25031 {
25032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25033 }
25034 return resultobj;
25035 fail:
25036 return NULL;
25037 }
25038
25039
25040 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25041 PyObject *resultobj = 0;
25042 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25043 bool result;
25044 void *argp1 = 0 ;
25045 int res1 = 0 ;
25046 PyObject *swig_obj[1] ;
25047
25048 if (!args) SWIG_fail;
25049 swig_obj[0] = args;
25050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25051 if (!SWIG_IsOK(res1)) {
25052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25053 }
25054 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25055 {
25056 PyThreadState* __tstate = wxPyBeginAllowThreads();
25057 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25058 wxPyEndAllowThreads(__tstate);
25059 if (PyErr_Occurred()) SWIG_fail;
25060 }
25061 {
25062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25063 }
25064 return resultobj;
25065 fail:
25066 return NULL;
25067 }
25068
25069
25070 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25071 PyObject *resultobj = 0;
25072 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25073 int result;
25074 void *argp1 = 0 ;
25075 int res1 = 0 ;
25076 PyObject *swig_obj[1] ;
25077
25078 if (!args) SWIG_fail;
25079 swig_obj[0] = args;
25080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25081 if (!SWIG_IsOK(res1)) {
25082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25083 }
25084 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25085 {
25086 PyThreadState* __tstate = wxPyBeginAllowThreads();
25087 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25088 wxPyEndAllowThreads(__tstate);
25089 if (PyErr_Occurred()) SWIG_fail;
25090 }
25091 resultobj = SWIG_From_int(static_cast< int >(result));
25092 return resultobj;
25093 fail:
25094 return NULL;
25095 }
25096
25097
25098 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25099 PyObject *resultobj = 0;
25100 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25101 int result;
25102 void *argp1 = 0 ;
25103 int res1 = 0 ;
25104 PyObject *swig_obj[1] ;
25105
25106 if (!args) SWIG_fail;
25107 swig_obj[0] = args;
25108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25109 if (!SWIG_IsOK(res1)) {
25110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25111 }
25112 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25113 {
25114 PyThreadState* __tstate = wxPyBeginAllowThreads();
25115 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25116 wxPyEndAllowThreads(__tstate);
25117 if (PyErr_Occurred()) SWIG_fail;
25118 }
25119 resultobj = SWIG_From_int(static_cast< int >(result));
25120 return resultobj;
25121 fail:
25122 return NULL;
25123 }
25124
25125
25126 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25127 PyObject *resultobj = 0;
25128 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25129 int arg2 ;
25130 void *argp1 = 0 ;
25131 int res1 = 0 ;
25132 int val2 ;
25133 int ecode2 = 0 ;
25134 PyObject * obj0 = 0 ;
25135 PyObject * obj1 = 0 ;
25136 char * kwnames[] = {
25137 (char *) "self",(char *) "uniChar", NULL
25138 };
25139
25140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25142 if (!SWIG_IsOK(res1)) {
25143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25144 }
25145 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25146 ecode2 = SWIG_AsVal_int(obj1, &val2);
25147 if (!SWIG_IsOK(ecode2)) {
25148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25149 }
25150 arg2 = static_cast< int >(val2);
25151 {
25152 PyThreadState* __tstate = wxPyBeginAllowThreads();
25153 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25154 wxPyEndAllowThreads(__tstate);
25155 if (PyErr_Occurred()) SWIG_fail;
25156 }
25157 resultobj = SWIG_Py_Void();
25158 return resultobj;
25159 fail:
25160 return NULL;
25161 }
25162
25163
25164 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25165 PyObject *resultobj = 0;
25166 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25167 unsigned int result;
25168 void *argp1 = 0 ;
25169 int res1 = 0 ;
25170 PyObject *swig_obj[1] ;
25171
25172 if (!args) SWIG_fail;
25173 swig_obj[0] = args;
25174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25175 if (!SWIG_IsOK(res1)) {
25176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25177 }
25178 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25179 {
25180 PyThreadState* __tstate = wxPyBeginAllowThreads();
25181 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25182 wxPyEndAllowThreads(__tstate);
25183 if (PyErr_Occurred()) SWIG_fail;
25184 }
25185 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25186 return resultobj;
25187 fail:
25188 return NULL;
25189 }
25190
25191
25192 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25193 PyObject *resultobj = 0;
25194 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25195 unsigned int result;
25196 void *argp1 = 0 ;
25197 int res1 = 0 ;
25198 PyObject *swig_obj[1] ;
25199
25200 if (!args) SWIG_fail;
25201 swig_obj[0] = args;
25202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25203 if (!SWIG_IsOK(res1)) {
25204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25205 }
25206 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25207 {
25208 PyThreadState* __tstate = wxPyBeginAllowThreads();
25209 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25210 wxPyEndAllowThreads(__tstate);
25211 if (PyErr_Occurred()) SWIG_fail;
25212 }
25213 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25214 return resultobj;
25215 fail:
25216 return NULL;
25217 }
25218
25219
25220 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25221 PyObject *resultobj = 0;
25222 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25223 wxPoint result;
25224 void *argp1 = 0 ;
25225 int res1 = 0 ;
25226 PyObject *swig_obj[1] ;
25227
25228 if (!args) SWIG_fail;
25229 swig_obj[0] = args;
25230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25231 if (!SWIG_IsOK(res1)) {
25232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25233 }
25234 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25235 {
25236 PyThreadState* __tstate = wxPyBeginAllowThreads();
25237 result = (arg1)->GetPosition();
25238 wxPyEndAllowThreads(__tstate);
25239 if (PyErr_Occurred()) SWIG_fail;
25240 }
25241 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25242 return resultobj;
25243 fail:
25244 return NULL;
25245 }
25246
25247
25248 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25249 PyObject *resultobj = 0;
25250 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25251 long *arg2 = (long *) 0 ;
25252 long *arg3 = (long *) 0 ;
25253 void *argp1 = 0 ;
25254 int res1 = 0 ;
25255 long temp2 ;
25256 int res2 = SWIG_TMPOBJ ;
25257 long temp3 ;
25258 int res3 = SWIG_TMPOBJ ;
25259 PyObject *swig_obj[1] ;
25260
25261 arg2 = &temp2;
25262 arg3 = &temp3;
25263 if (!args) SWIG_fail;
25264 swig_obj[0] = args;
25265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25266 if (!SWIG_IsOK(res1)) {
25267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25268 }
25269 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25270 {
25271 PyThreadState* __tstate = wxPyBeginAllowThreads();
25272 (arg1)->GetPosition(arg2,arg3);
25273 wxPyEndAllowThreads(__tstate);
25274 if (PyErr_Occurred()) SWIG_fail;
25275 }
25276 resultobj = SWIG_Py_Void();
25277 if (SWIG_IsTmpObj(res2)) {
25278 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25279 } else {
25280 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25281 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25282 }
25283 if (SWIG_IsTmpObj(res3)) {
25284 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25285 } else {
25286 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25287 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25288 }
25289 return resultobj;
25290 fail:
25291 return NULL;
25292 }
25293
25294
25295 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25296 PyObject *resultobj = 0;
25297 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25298 int result;
25299 void *argp1 = 0 ;
25300 int res1 = 0 ;
25301 PyObject *swig_obj[1] ;
25302
25303 if (!args) SWIG_fail;
25304 swig_obj[0] = args;
25305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25306 if (!SWIG_IsOK(res1)) {
25307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25308 }
25309 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25310 {
25311 PyThreadState* __tstate = wxPyBeginAllowThreads();
25312 result = (int)((wxKeyEvent const *)arg1)->GetX();
25313 wxPyEndAllowThreads(__tstate);
25314 if (PyErr_Occurred()) SWIG_fail;
25315 }
25316 resultobj = SWIG_From_int(static_cast< int >(result));
25317 return resultobj;
25318 fail:
25319 return NULL;
25320 }
25321
25322
25323 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25324 PyObject *resultobj = 0;
25325 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25326 int result;
25327 void *argp1 = 0 ;
25328 int res1 = 0 ;
25329 PyObject *swig_obj[1] ;
25330
25331 if (!args) SWIG_fail;
25332 swig_obj[0] = args;
25333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25334 if (!SWIG_IsOK(res1)) {
25335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25336 }
25337 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25338 {
25339 PyThreadState* __tstate = wxPyBeginAllowThreads();
25340 result = (int)((wxKeyEvent const *)arg1)->GetY();
25341 wxPyEndAllowThreads(__tstate);
25342 if (PyErr_Occurred()) SWIG_fail;
25343 }
25344 resultobj = SWIG_From_int(static_cast< int >(result));
25345 return resultobj;
25346 fail:
25347 return NULL;
25348 }
25349
25350
25351 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25352 PyObject *resultobj = 0;
25353 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25354 int arg2 ;
25355 void *argp1 = 0 ;
25356 int res1 = 0 ;
25357 int val2 ;
25358 int ecode2 = 0 ;
25359 PyObject *swig_obj[2] ;
25360
25361 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25363 if (!SWIG_IsOK(res1)) {
25364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25365 }
25366 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25367 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25368 if (!SWIG_IsOK(ecode2)) {
25369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25370 }
25371 arg2 = static_cast< int >(val2);
25372 if (arg1) (arg1)->m_x = arg2;
25373
25374 resultobj = SWIG_Py_Void();
25375 return resultobj;
25376 fail:
25377 return NULL;
25378 }
25379
25380
25381 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25382 PyObject *resultobj = 0;
25383 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25384 int result;
25385 void *argp1 = 0 ;
25386 int res1 = 0 ;
25387 PyObject *swig_obj[1] ;
25388
25389 if (!args) SWIG_fail;
25390 swig_obj[0] = args;
25391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25392 if (!SWIG_IsOK(res1)) {
25393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25394 }
25395 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25396 result = (int) ((arg1)->m_x);
25397 resultobj = SWIG_From_int(static_cast< int >(result));
25398 return resultobj;
25399 fail:
25400 return NULL;
25401 }
25402
25403
25404 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25405 PyObject *resultobj = 0;
25406 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25407 int arg2 ;
25408 void *argp1 = 0 ;
25409 int res1 = 0 ;
25410 int val2 ;
25411 int ecode2 = 0 ;
25412 PyObject *swig_obj[2] ;
25413
25414 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25416 if (!SWIG_IsOK(res1)) {
25417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25418 }
25419 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25420 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25421 if (!SWIG_IsOK(ecode2)) {
25422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25423 }
25424 arg2 = static_cast< int >(val2);
25425 if (arg1) (arg1)->m_y = arg2;
25426
25427 resultobj = SWIG_Py_Void();
25428 return resultobj;
25429 fail:
25430 return NULL;
25431 }
25432
25433
25434 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25435 PyObject *resultobj = 0;
25436 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25437 int result;
25438 void *argp1 = 0 ;
25439 int res1 = 0 ;
25440 PyObject *swig_obj[1] ;
25441
25442 if (!args) SWIG_fail;
25443 swig_obj[0] = args;
25444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25445 if (!SWIG_IsOK(res1)) {
25446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25447 }
25448 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25449 result = (int) ((arg1)->m_y);
25450 resultobj = SWIG_From_int(static_cast< int >(result));
25451 return resultobj;
25452 fail:
25453 return NULL;
25454 }
25455
25456
25457 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25458 PyObject *resultobj = 0;
25459 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25460 long arg2 ;
25461 void *argp1 = 0 ;
25462 int res1 = 0 ;
25463 long val2 ;
25464 int ecode2 = 0 ;
25465 PyObject *swig_obj[2] ;
25466
25467 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25469 if (!SWIG_IsOK(res1)) {
25470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25471 }
25472 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25473 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25474 if (!SWIG_IsOK(ecode2)) {
25475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25476 }
25477 arg2 = static_cast< long >(val2);
25478 if (arg1) (arg1)->m_keyCode = arg2;
25479
25480 resultobj = SWIG_Py_Void();
25481 return resultobj;
25482 fail:
25483 return NULL;
25484 }
25485
25486
25487 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25488 PyObject *resultobj = 0;
25489 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25490 long result;
25491 void *argp1 = 0 ;
25492 int res1 = 0 ;
25493 PyObject *swig_obj[1] ;
25494
25495 if (!args) SWIG_fail;
25496 swig_obj[0] = args;
25497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25498 if (!SWIG_IsOK(res1)) {
25499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25500 }
25501 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25502 result = (long) ((arg1)->m_keyCode);
25503 resultobj = SWIG_From_long(static_cast< long >(result));
25504 return resultobj;
25505 fail:
25506 return NULL;
25507 }
25508
25509
25510 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25511 PyObject *resultobj = 0;
25512 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25513 bool arg2 ;
25514 void *argp1 = 0 ;
25515 int res1 = 0 ;
25516 bool val2 ;
25517 int ecode2 = 0 ;
25518 PyObject *swig_obj[2] ;
25519
25520 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25522 if (!SWIG_IsOK(res1)) {
25523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25524 }
25525 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25526 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25527 if (!SWIG_IsOK(ecode2)) {
25528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25529 }
25530 arg2 = static_cast< bool >(val2);
25531 if (arg1) (arg1)->m_controlDown = arg2;
25532
25533 resultobj = SWIG_Py_Void();
25534 return resultobj;
25535 fail:
25536 return NULL;
25537 }
25538
25539
25540 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25541 PyObject *resultobj = 0;
25542 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25543 bool result;
25544 void *argp1 = 0 ;
25545 int res1 = 0 ;
25546 PyObject *swig_obj[1] ;
25547
25548 if (!args) SWIG_fail;
25549 swig_obj[0] = args;
25550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25551 if (!SWIG_IsOK(res1)) {
25552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25553 }
25554 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25555 result = (bool) ((arg1)->m_controlDown);
25556 {
25557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25558 }
25559 return resultobj;
25560 fail:
25561 return NULL;
25562 }
25563
25564
25565 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25566 PyObject *resultobj = 0;
25567 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25568 bool arg2 ;
25569 void *argp1 = 0 ;
25570 int res1 = 0 ;
25571 bool val2 ;
25572 int ecode2 = 0 ;
25573 PyObject *swig_obj[2] ;
25574
25575 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25577 if (!SWIG_IsOK(res1)) {
25578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25579 }
25580 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25581 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25582 if (!SWIG_IsOK(ecode2)) {
25583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25584 }
25585 arg2 = static_cast< bool >(val2);
25586 if (arg1) (arg1)->m_shiftDown = arg2;
25587
25588 resultobj = SWIG_Py_Void();
25589 return resultobj;
25590 fail:
25591 return NULL;
25592 }
25593
25594
25595 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25596 PyObject *resultobj = 0;
25597 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25598 bool result;
25599 void *argp1 = 0 ;
25600 int res1 = 0 ;
25601 PyObject *swig_obj[1] ;
25602
25603 if (!args) SWIG_fail;
25604 swig_obj[0] = args;
25605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25606 if (!SWIG_IsOK(res1)) {
25607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25608 }
25609 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25610 result = (bool) ((arg1)->m_shiftDown);
25611 {
25612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25613 }
25614 return resultobj;
25615 fail:
25616 return NULL;
25617 }
25618
25619
25620 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25621 PyObject *resultobj = 0;
25622 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25623 bool arg2 ;
25624 void *argp1 = 0 ;
25625 int res1 = 0 ;
25626 bool val2 ;
25627 int ecode2 = 0 ;
25628 PyObject *swig_obj[2] ;
25629
25630 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25632 if (!SWIG_IsOK(res1)) {
25633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25634 }
25635 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25636 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25637 if (!SWIG_IsOK(ecode2)) {
25638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25639 }
25640 arg2 = static_cast< bool >(val2);
25641 if (arg1) (arg1)->m_altDown = arg2;
25642
25643 resultobj = SWIG_Py_Void();
25644 return resultobj;
25645 fail:
25646 return NULL;
25647 }
25648
25649
25650 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25651 PyObject *resultobj = 0;
25652 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25653 bool result;
25654 void *argp1 = 0 ;
25655 int res1 = 0 ;
25656 PyObject *swig_obj[1] ;
25657
25658 if (!args) SWIG_fail;
25659 swig_obj[0] = args;
25660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25661 if (!SWIG_IsOK(res1)) {
25662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25663 }
25664 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25665 result = (bool) ((arg1)->m_altDown);
25666 {
25667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25668 }
25669 return resultobj;
25670 fail:
25671 return NULL;
25672 }
25673
25674
25675 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25676 PyObject *resultobj = 0;
25677 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25678 bool arg2 ;
25679 void *argp1 = 0 ;
25680 int res1 = 0 ;
25681 bool val2 ;
25682 int ecode2 = 0 ;
25683 PyObject *swig_obj[2] ;
25684
25685 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25687 if (!SWIG_IsOK(res1)) {
25688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25689 }
25690 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25691 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25692 if (!SWIG_IsOK(ecode2)) {
25693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25694 }
25695 arg2 = static_cast< bool >(val2);
25696 if (arg1) (arg1)->m_metaDown = arg2;
25697
25698 resultobj = SWIG_Py_Void();
25699 return resultobj;
25700 fail:
25701 return NULL;
25702 }
25703
25704
25705 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25706 PyObject *resultobj = 0;
25707 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25708 bool result;
25709 void *argp1 = 0 ;
25710 int res1 = 0 ;
25711 PyObject *swig_obj[1] ;
25712
25713 if (!args) SWIG_fail;
25714 swig_obj[0] = args;
25715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25716 if (!SWIG_IsOK(res1)) {
25717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25718 }
25719 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25720 result = (bool) ((arg1)->m_metaDown);
25721 {
25722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25723 }
25724 return resultobj;
25725 fail:
25726 return NULL;
25727 }
25728
25729
25730 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25731 PyObject *resultobj = 0;
25732 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25733 bool arg2 ;
25734 void *argp1 = 0 ;
25735 int res1 = 0 ;
25736 bool val2 ;
25737 int ecode2 = 0 ;
25738 PyObject *swig_obj[2] ;
25739
25740 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25742 if (!SWIG_IsOK(res1)) {
25743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25744 }
25745 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25746 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25747 if (!SWIG_IsOK(ecode2)) {
25748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25749 }
25750 arg2 = static_cast< bool >(val2);
25751 if (arg1) (arg1)->m_scanCode = arg2;
25752
25753 resultobj = SWIG_Py_Void();
25754 return resultobj;
25755 fail:
25756 return NULL;
25757 }
25758
25759
25760 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25761 PyObject *resultobj = 0;
25762 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25763 bool result;
25764 void *argp1 = 0 ;
25765 int res1 = 0 ;
25766 PyObject *swig_obj[1] ;
25767
25768 if (!args) SWIG_fail;
25769 swig_obj[0] = args;
25770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25771 if (!SWIG_IsOK(res1)) {
25772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25773 }
25774 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25775 result = (bool) ((arg1)->m_scanCode);
25776 {
25777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25778 }
25779 return resultobj;
25780 fail:
25781 return NULL;
25782 }
25783
25784
25785 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25786 PyObject *resultobj = 0;
25787 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25788 unsigned int arg2 ;
25789 void *argp1 = 0 ;
25790 int res1 = 0 ;
25791 unsigned int val2 ;
25792 int ecode2 = 0 ;
25793 PyObject *swig_obj[2] ;
25794
25795 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25797 if (!SWIG_IsOK(res1)) {
25798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25799 }
25800 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25801 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25802 if (!SWIG_IsOK(ecode2)) {
25803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25804 }
25805 arg2 = static_cast< unsigned int >(val2);
25806 if (arg1) (arg1)->m_rawCode = arg2;
25807
25808 resultobj = SWIG_Py_Void();
25809 return resultobj;
25810 fail:
25811 return NULL;
25812 }
25813
25814
25815 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25816 PyObject *resultobj = 0;
25817 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25818 unsigned int result;
25819 void *argp1 = 0 ;
25820 int res1 = 0 ;
25821 PyObject *swig_obj[1] ;
25822
25823 if (!args) SWIG_fail;
25824 swig_obj[0] = args;
25825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25826 if (!SWIG_IsOK(res1)) {
25827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25828 }
25829 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25830 result = (unsigned int) ((arg1)->m_rawCode);
25831 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25832 return resultobj;
25833 fail:
25834 return NULL;
25835 }
25836
25837
25838 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25839 PyObject *resultobj = 0;
25840 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25841 unsigned int arg2 ;
25842 void *argp1 = 0 ;
25843 int res1 = 0 ;
25844 unsigned int val2 ;
25845 int ecode2 = 0 ;
25846 PyObject *swig_obj[2] ;
25847
25848 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25850 if (!SWIG_IsOK(res1)) {
25851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25852 }
25853 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25854 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25855 if (!SWIG_IsOK(ecode2)) {
25856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25857 }
25858 arg2 = static_cast< unsigned int >(val2);
25859 if (arg1) (arg1)->m_rawFlags = arg2;
25860
25861 resultobj = SWIG_Py_Void();
25862 return resultobj;
25863 fail:
25864 return NULL;
25865 }
25866
25867
25868 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25869 PyObject *resultobj = 0;
25870 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25871 unsigned int result;
25872 void *argp1 = 0 ;
25873 int res1 = 0 ;
25874 PyObject *swig_obj[1] ;
25875
25876 if (!args) SWIG_fail;
25877 swig_obj[0] = args;
25878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25879 if (!SWIG_IsOK(res1)) {
25880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25881 }
25882 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25883 result = (unsigned int) ((arg1)->m_rawFlags);
25884 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25885 return resultobj;
25886 fail:
25887 return NULL;
25888 }
25889
25890
25891 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25892 PyObject *obj;
25893 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25894 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25895 return SWIG_Py_Void();
25896 }
25897
25898 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25899 return SWIG_Python_InitShadowInstance(args);
25900 }
25901
25902 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25903 PyObject *resultobj = 0;
25904 wxSize const &arg1_defvalue = wxDefaultSize ;
25905 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
25906 int arg2 = (int) 0 ;
25907 wxSizeEvent *result = 0 ;
25908 wxSize temp1 ;
25909 int val2 ;
25910 int ecode2 = 0 ;
25911 PyObject * obj0 = 0 ;
25912 PyObject * obj1 = 0 ;
25913 char * kwnames[] = {
25914 (char *) "sz",(char *) "winid", NULL
25915 };
25916
25917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25918 if (obj0) {
25919 {
25920 arg1 = &temp1;
25921 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
25922 }
25923 }
25924 if (obj1) {
25925 ecode2 = SWIG_AsVal_int(obj1, &val2);
25926 if (!SWIG_IsOK(ecode2)) {
25927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
25928 }
25929 arg2 = static_cast< int >(val2);
25930 }
25931 {
25932 PyThreadState* __tstate = wxPyBeginAllowThreads();
25933 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
25934 wxPyEndAllowThreads(__tstate);
25935 if (PyErr_Occurred()) SWIG_fail;
25936 }
25937 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
25938 return resultobj;
25939 fail:
25940 return NULL;
25941 }
25942
25943
25944 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25945 PyObject *resultobj = 0;
25946 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25947 wxSize result;
25948 void *argp1 = 0 ;
25949 int res1 = 0 ;
25950 PyObject *swig_obj[1] ;
25951
25952 if (!args) SWIG_fail;
25953 swig_obj[0] = args;
25954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
25955 if (!SWIG_IsOK(res1)) {
25956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25957 }
25958 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25959 {
25960 PyThreadState* __tstate = wxPyBeginAllowThreads();
25961 result = ((wxSizeEvent const *)arg1)->GetSize();
25962 wxPyEndAllowThreads(__tstate);
25963 if (PyErr_Occurred()) SWIG_fail;
25964 }
25965 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
25966 return resultobj;
25967 fail:
25968 return NULL;
25969 }
25970
25971
25972 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25973 PyObject *resultobj = 0;
25974 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25975 wxRect result;
25976 void *argp1 = 0 ;
25977 int res1 = 0 ;
25978 PyObject *swig_obj[1] ;
25979
25980 if (!args) SWIG_fail;
25981 swig_obj[0] = args;
25982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
25983 if (!SWIG_IsOK(res1)) {
25984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25985 }
25986 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25987 {
25988 PyThreadState* __tstate = wxPyBeginAllowThreads();
25989 result = ((wxSizeEvent const *)arg1)->GetRect();
25990 wxPyEndAllowThreads(__tstate);
25991 if (PyErr_Occurred()) SWIG_fail;
25992 }
25993 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
25994 return resultobj;
25995 fail:
25996 return NULL;
25997 }
25998
25999
26000 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26001 PyObject *resultobj = 0;
26002 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26003 wxRect arg2 ;
26004 void *argp1 = 0 ;
26005 int res1 = 0 ;
26006 void *argp2 ;
26007 int res2 = 0 ;
26008 PyObject * obj0 = 0 ;
26009 PyObject * obj1 = 0 ;
26010 char * kwnames[] = {
26011 (char *) "self",(char *) "rect", NULL
26012 };
26013
26014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26016 if (!SWIG_IsOK(res1)) {
26017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26018 }
26019 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26020 {
26021 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26022 if (!SWIG_IsOK(res2)) {
26023 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26024 }
26025 if (!argp2) {
26026 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26027 } else {
26028 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26029 arg2 = *temp;
26030 if (SWIG_IsNewObj(res2)) delete temp;
26031 }
26032 }
26033 {
26034 PyThreadState* __tstate = wxPyBeginAllowThreads();
26035 (arg1)->SetRect(arg2);
26036 wxPyEndAllowThreads(__tstate);
26037 if (PyErr_Occurred()) SWIG_fail;
26038 }
26039 resultobj = SWIG_Py_Void();
26040 return resultobj;
26041 fail:
26042 return NULL;
26043 }
26044
26045
26046 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26047 PyObject *resultobj = 0;
26048 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26049 wxSize arg2 ;
26050 void *argp1 = 0 ;
26051 int res1 = 0 ;
26052 void *argp2 ;
26053 int res2 = 0 ;
26054 PyObject * obj0 = 0 ;
26055 PyObject * obj1 = 0 ;
26056 char * kwnames[] = {
26057 (char *) "self",(char *) "size", NULL
26058 };
26059
26060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26062 if (!SWIG_IsOK(res1)) {
26063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26064 }
26065 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26066 {
26067 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26068 if (!SWIG_IsOK(res2)) {
26069 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26070 }
26071 if (!argp2) {
26072 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26073 } else {
26074 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26075 arg2 = *temp;
26076 if (SWIG_IsNewObj(res2)) delete temp;
26077 }
26078 }
26079 {
26080 PyThreadState* __tstate = wxPyBeginAllowThreads();
26081 wxSizeEvent_SetSize(arg1,arg2);
26082 wxPyEndAllowThreads(__tstate);
26083 if (PyErr_Occurred()) SWIG_fail;
26084 }
26085 resultobj = SWIG_Py_Void();
26086 return resultobj;
26087 fail:
26088 return NULL;
26089 }
26090
26091
26092 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26093 PyObject *resultobj = 0;
26094 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26095 wxSize *arg2 = (wxSize *) 0 ;
26096 void *argp1 = 0 ;
26097 int res1 = 0 ;
26098 void *argp2 = 0 ;
26099 int res2 = 0 ;
26100 PyObject *swig_obj[2] ;
26101
26102 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26104 if (!SWIG_IsOK(res1)) {
26105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26106 }
26107 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26108 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26109 if (!SWIG_IsOK(res2)) {
26110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26111 }
26112 arg2 = reinterpret_cast< wxSize * >(argp2);
26113 if (arg1) (arg1)->m_size = *arg2;
26114
26115 resultobj = SWIG_Py_Void();
26116 return resultobj;
26117 fail:
26118 return NULL;
26119 }
26120
26121
26122 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26123 PyObject *resultobj = 0;
26124 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26125 wxSize *result = 0 ;
26126 void *argp1 = 0 ;
26127 int res1 = 0 ;
26128 PyObject *swig_obj[1] ;
26129
26130 if (!args) SWIG_fail;
26131 swig_obj[0] = args;
26132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26133 if (!SWIG_IsOK(res1)) {
26134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26135 }
26136 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26137 result = (wxSize *)& ((arg1)->m_size);
26138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26139 return resultobj;
26140 fail:
26141 return NULL;
26142 }
26143
26144
26145 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26146 PyObject *resultobj = 0;
26147 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26148 wxRect *arg2 = (wxRect *) 0 ;
26149 void *argp1 = 0 ;
26150 int res1 = 0 ;
26151 void *argp2 = 0 ;
26152 int res2 = 0 ;
26153 PyObject *swig_obj[2] ;
26154
26155 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26157 if (!SWIG_IsOK(res1)) {
26158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26159 }
26160 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26161 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26162 if (!SWIG_IsOK(res2)) {
26163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26164 }
26165 arg2 = reinterpret_cast< wxRect * >(argp2);
26166 if (arg1) (arg1)->m_rect = *arg2;
26167
26168 resultobj = SWIG_Py_Void();
26169 return resultobj;
26170 fail:
26171 return NULL;
26172 }
26173
26174
26175 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26176 PyObject *resultobj = 0;
26177 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26178 wxRect *result = 0 ;
26179 void *argp1 = 0 ;
26180 int res1 = 0 ;
26181 PyObject *swig_obj[1] ;
26182
26183 if (!args) SWIG_fail;
26184 swig_obj[0] = args;
26185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26186 if (!SWIG_IsOK(res1)) {
26187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26188 }
26189 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26190 result = (wxRect *)& ((arg1)->m_rect);
26191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26192 return resultobj;
26193 fail:
26194 return NULL;
26195 }
26196
26197
26198 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26199 PyObject *obj;
26200 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26201 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26202 return SWIG_Py_Void();
26203 }
26204
26205 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26206 return SWIG_Python_InitShadowInstance(args);
26207 }
26208
26209 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26210 PyObject *resultobj = 0;
26211 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26212 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26213 int arg2 = (int) 0 ;
26214 wxMoveEvent *result = 0 ;
26215 wxPoint temp1 ;
26216 int val2 ;
26217 int ecode2 = 0 ;
26218 PyObject * obj0 = 0 ;
26219 PyObject * obj1 = 0 ;
26220 char * kwnames[] = {
26221 (char *) "pos",(char *) "winid", NULL
26222 };
26223
26224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26225 if (obj0) {
26226 {
26227 arg1 = &temp1;
26228 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26229 }
26230 }
26231 if (obj1) {
26232 ecode2 = SWIG_AsVal_int(obj1, &val2);
26233 if (!SWIG_IsOK(ecode2)) {
26234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26235 }
26236 arg2 = static_cast< int >(val2);
26237 }
26238 {
26239 PyThreadState* __tstate = wxPyBeginAllowThreads();
26240 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26241 wxPyEndAllowThreads(__tstate);
26242 if (PyErr_Occurred()) SWIG_fail;
26243 }
26244 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26245 return resultobj;
26246 fail:
26247 return NULL;
26248 }
26249
26250
26251 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26252 PyObject *resultobj = 0;
26253 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26254 wxPoint result;
26255 void *argp1 = 0 ;
26256 int res1 = 0 ;
26257 PyObject *swig_obj[1] ;
26258
26259 if (!args) SWIG_fail;
26260 swig_obj[0] = args;
26261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26262 if (!SWIG_IsOK(res1)) {
26263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26264 }
26265 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26266 {
26267 PyThreadState* __tstate = wxPyBeginAllowThreads();
26268 result = ((wxMoveEvent const *)arg1)->GetPosition();
26269 wxPyEndAllowThreads(__tstate);
26270 if (PyErr_Occurred()) SWIG_fail;
26271 }
26272 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26273 return resultobj;
26274 fail:
26275 return NULL;
26276 }
26277
26278
26279 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26280 PyObject *resultobj = 0;
26281 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26282 wxRect result;
26283 void *argp1 = 0 ;
26284 int res1 = 0 ;
26285 PyObject *swig_obj[1] ;
26286
26287 if (!args) SWIG_fail;
26288 swig_obj[0] = args;
26289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26290 if (!SWIG_IsOK(res1)) {
26291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26292 }
26293 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26294 {
26295 PyThreadState* __tstate = wxPyBeginAllowThreads();
26296 result = ((wxMoveEvent const *)arg1)->GetRect();
26297 wxPyEndAllowThreads(__tstate);
26298 if (PyErr_Occurred()) SWIG_fail;
26299 }
26300 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26301 return resultobj;
26302 fail:
26303 return NULL;
26304 }
26305
26306
26307 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26308 PyObject *resultobj = 0;
26309 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26310 wxRect *arg2 = 0 ;
26311 void *argp1 = 0 ;
26312 int res1 = 0 ;
26313 wxRect temp2 ;
26314 PyObject * obj0 = 0 ;
26315 PyObject * obj1 = 0 ;
26316 char * kwnames[] = {
26317 (char *) "self",(char *) "rect", NULL
26318 };
26319
26320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26322 if (!SWIG_IsOK(res1)) {
26323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26324 }
26325 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26326 {
26327 arg2 = &temp2;
26328 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26329 }
26330 {
26331 PyThreadState* __tstate = wxPyBeginAllowThreads();
26332 (arg1)->SetRect((wxRect const &)*arg2);
26333 wxPyEndAllowThreads(__tstate);
26334 if (PyErr_Occurred()) SWIG_fail;
26335 }
26336 resultobj = SWIG_Py_Void();
26337 return resultobj;
26338 fail:
26339 return NULL;
26340 }
26341
26342
26343 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26344 PyObject *resultobj = 0;
26345 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26346 wxPoint *arg2 = 0 ;
26347 void *argp1 = 0 ;
26348 int res1 = 0 ;
26349 wxPoint temp2 ;
26350 PyObject * obj0 = 0 ;
26351 PyObject * obj1 = 0 ;
26352 char * kwnames[] = {
26353 (char *) "self",(char *) "pos", NULL
26354 };
26355
26356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26358 if (!SWIG_IsOK(res1)) {
26359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26360 }
26361 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26362 {
26363 arg2 = &temp2;
26364 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26365 }
26366 {
26367 PyThreadState* __tstate = wxPyBeginAllowThreads();
26368 (arg1)->SetPosition((wxPoint const &)*arg2);
26369 wxPyEndAllowThreads(__tstate);
26370 if (PyErr_Occurred()) SWIG_fail;
26371 }
26372 resultobj = SWIG_Py_Void();
26373 return resultobj;
26374 fail:
26375 return NULL;
26376 }
26377
26378
26379 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26380 PyObject *obj;
26381 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26382 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26383 return SWIG_Py_Void();
26384 }
26385
26386 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26387 return SWIG_Python_InitShadowInstance(args);
26388 }
26389
26390 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26391 PyObject *resultobj = 0;
26392 int arg1 = (int) 0 ;
26393 wxPaintEvent *result = 0 ;
26394 int val1 ;
26395 int ecode1 = 0 ;
26396 PyObject * obj0 = 0 ;
26397 char * kwnames[] = {
26398 (char *) "Id", NULL
26399 };
26400
26401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26402 if (obj0) {
26403 ecode1 = SWIG_AsVal_int(obj0, &val1);
26404 if (!SWIG_IsOK(ecode1)) {
26405 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26406 }
26407 arg1 = static_cast< int >(val1);
26408 }
26409 {
26410 PyThreadState* __tstate = wxPyBeginAllowThreads();
26411 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26412 wxPyEndAllowThreads(__tstate);
26413 if (PyErr_Occurred()) SWIG_fail;
26414 }
26415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26416 return resultobj;
26417 fail:
26418 return NULL;
26419 }
26420
26421
26422 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26423 PyObject *obj;
26424 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26425 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26426 return SWIG_Py_Void();
26427 }
26428
26429 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26430 return SWIG_Python_InitShadowInstance(args);
26431 }
26432
26433 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26434 PyObject *resultobj = 0;
26435 int arg1 = (int) 0 ;
26436 wxNcPaintEvent *result = 0 ;
26437 int val1 ;
26438 int ecode1 = 0 ;
26439 PyObject * obj0 = 0 ;
26440 char * kwnames[] = {
26441 (char *) "winid", NULL
26442 };
26443
26444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) 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_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26449 }
26450 arg1 = static_cast< int >(val1);
26451 }
26452 {
26453 PyThreadState* __tstate = wxPyBeginAllowThreads();
26454 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26455 wxPyEndAllowThreads(__tstate);
26456 if (PyErr_Occurred()) SWIG_fail;
26457 }
26458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26459 return resultobj;
26460 fail:
26461 return NULL;
26462 }
26463
26464
26465 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26466 PyObject *obj;
26467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26468 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26469 return SWIG_Py_Void();
26470 }
26471
26472 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26473 return SWIG_Python_InitShadowInstance(args);
26474 }
26475
26476 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26477 PyObject *resultobj = 0;
26478 int arg1 = (int) 0 ;
26479 wxDC *arg2 = (wxDC *) NULL ;
26480 wxEraseEvent *result = 0 ;
26481 int val1 ;
26482 int ecode1 = 0 ;
26483 void *argp2 = 0 ;
26484 int res2 = 0 ;
26485 PyObject * obj0 = 0 ;
26486 PyObject * obj1 = 0 ;
26487 char * kwnames[] = {
26488 (char *) "Id",(char *) "dc", NULL
26489 };
26490
26491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26492 if (obj0) {
26493 ecode1 = SWIG_AsVal_int(obj0, &val1);
26494 if (!SWIG_IsOK(ecode1)) {
26495 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26496 }
26497 arg1 = static_cast< int >(val1);
26498 }
26499 if (obj1) {
26500 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26501 if (!SWIG_IsOK(res2)) {
26502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26503 }
26504 arg2 = reinterpret_cast< wxDC * >(argp2);
26505 }
26506 {
26507 PyThreadState* __tstate = wxPyBeginAllowThreads();
26508 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26509 wxPyEndAllowThreads(__tstate);
26510 if (PyErr_Occurred()) SWIG_fail;
26511 }
26512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26513 return resultobj;
26514 fail:
26515 return NULL;
26516 }
26517
26518
26519 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26520 PyObject *resultobj = 0;
26521 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26522 wxDC *result = 0 ;
26523 void *argp1 = 0 ;
26524 int res1 = 0 ;
26525 PyObject *swig_obj[1] ;
26526
26527 if (!args) SWIG_fail;
26528 swig_obj[0] = args;
26529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26530 if (!SWIG_IsOK(res1)) {
26531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26532 }
26533 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26534 {
26535 PyThreadState* __tstate = wxPyBeginAllowThreads();
26536 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26537 wxPyEndAllowThreads(__tstate);
26538 if (PyErr_Occurred()) SWIG_fail;
26539 }
26540 {
26541 resultobj = wxPyMake_wxObject(result, (bool)0);
26542 }
26543 return resultobj;
26544 fail:
26545 return NULL;
26546 }
26547
26548
26549 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26550 PyObject *obj;
26551 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26552 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26553 return SWIG_Py_Void();
26554 }
26555
26556 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26557 return SWIG_Python_InitShadowInstance(args);
26558 }
26559
26560 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26561 PyObject *resultobj = 0;
26562 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26563 int arg2 = (int) 0 ;
26564 wxFocusEvent *result = 0 ;
26565 int val1 ;
26566 int ecode1 = 0 ;
26567 int val2 ;
26568 int ecode2 = 0 ;
26569 PyObject * obj0 = 0 ;
26570 PyObject * obj1 = 0 ;
26571 char * kwnames[] = {
26572 (char *) "type",(char *) "winid", NULL
26573 };
26574
26575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26576 if (obj0) {
26577 ecode1 = SWIG_AsVal_int(obj0, &val1);
26578 if (!SWIG_IsOK(ecode1)) {
26579 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26580 }
26581 arg1 = static_cast< wxEventType >(val1);
26582 }
26583 if (obj1) {
26584 ecode2 = SWIG_AsVal_int(obj1, &val2);
26585 if (!SWIG_IsOK(ecode2)) {
26586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26587 }
26588 arg2 = static_cast< int >(val2);
26589 }
26590 {
26591 PyThreadState* __tstate = wxPyBeginAllowThreads();
26592 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26593 wxPyEndAllowThreads(__tstate);
26594 if (PyErr_Occurred()) SWIG_fail;
26595 }
26596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26597 return resultobj;
26598 fail:
26599 return NULL;
26600 }
26601
26602
26603 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26604 PyObject *resultobj = 0;
26605 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26606 wxWindow *result = 0 ;
26607 void *argp1 = 0 ;
26608 int res1 = 0 ;
26609 PyObject *swig_obj[1] ;
26610
26611 if (!args) SWIG_fail;
26612 swig_obj[0] = args;
26613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26614 if (!SWIG_IsOK(res1)) {
26615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26616 }
26617 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26618 {
26619 PyThreadState* __tstate = wxPyBeginAllowThreads();
26620 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26621 wxPyEndAllowThreads(__tstate);
26622 if (PyErr_Occurred()) SWIG_fail;
26623 }
26624 {
26625 resultobj = wxPyMake_wxObject(result, (bool)0);
26626 }
26627 return resultobj;
26628 fail:
26629 return NULL;
26630 }
26631
26632
26633 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26634 PyObject *resultobj = 0;
26635 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26636 wxWindow *arg2 = (wxWindow *) 0 ;
26637 void *argp1 = 0 ;
26638 int res1 = 0 ;
26639 void *argp2 = 0 ;
26640 int res2 = 0 ;
26641 PyObject * obj0 = 0 ;
26642 PyObject * obj1 = 0 ;
26643 char * kwnames[] = {
26644 (char *) "self",(char *) "win", NULL
26645 };
26646
26647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26649 if (!SWIG_IsOK(res1)) {
26650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26651 }
26652 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26653 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26654 if (!SWIG_IsOK(res2)) {
26655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26656 }
26657 arg2 = reinterpret_cast< wxWindow * >(argp2);
26658 {
26659 PyThreadState* __tstate = wxPyBeginAllowThreads();
26660 (arg1)->SetWindow(arg2);
26661 wxPyEndAllowThreads(__tstate);
26662 if (PyErr_Occurred()) SWIG_fail;
26663 }
26664 resultobj = SWIG_Py_Void();
26665 return resultobj;
26666 fail:
26667 return NULL;
26668 }
26669
26670
26671 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26672 PyObject *obj;
26673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26674 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26675 return SWIG_Py_Void();
26676 }
26677
26678 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26679 return SWIG_Python_InitShadowInstance(args);
26680 }
26681
26682 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26683 PyObject *resultobj = 0;
26684 wxWindow *arg1 = (wxWindow *) NULL ;
26685 wxChildFocusEvent *result = 0 ;
26686 void *argp1 = 0 ;
26687 int res1 = 0 ;
26688 PyObject * obj0 = 0 ;
26689 char * kwnames[] = {
26690 (char *) "win", NULL
26691 };
26692
26693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26694 if (obj0) {
26695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26696 if (!SWIG_IsOK(res1)) {
26697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26698 }
26699 arg1 = reinterpret_cast< wxWindow * >(argp1);
26700 }
26701 {
26702 PyThreadState* __tstate = wxPyBeginAllowThreads();
26703 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26704 wxPyEndAllowThreads(__tstate);
26705 if (PyErr_Occurred()) SWIG_fail;
26706 }
26707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26708 return resultobj;
26709 fail:
26710 return NULL;
26711 }
26712
26713
26714 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26715 PyObject *resultobj = 0;
26716 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26717 wxWindow *result = 0 ;
26718 void *argp1 = 0 ;
26719 int res1 = 0 ;
26720 PyObject *swig_obj[1] ;
26721
26722 if (!args) SWIG_fail;
26723 swig_obj[0] = args;
26724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26725 if (!SWIG_IsOK(res1)) {
26726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26727 }
26728 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26729 {
26730 PyThreadState* __tstate = wxPyBeginAllowThreads();
26731 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26732 wxPyEndAllowThreads(__tstate);
26733 if (PyErr_Occurred()) SWIG_fail;
26734 }
26735 {
26736 resultobj = wxPyMake_wxObject(result, (bool)0);
26737 }
26738 return resultobj;
26739 fail:
26740 return NULL;
26741 }
26742
26743
26744 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26745 PyObject *obj;
26746 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26747 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26748 return SWIG_Py_Void();
26749 }
26750
26751 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26752 return SWIG_Python_InitShadowInstance(args);
26753 }
26754
26755 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26756 PyObject *resultobj = 0;
26757 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26758 bool arg2 = (bool) true ;
26759 int arg3 = (int) 0 ;
26760 wxActivateEvent *result = 0 ;
26761 int val1 ;
26762 int ecode1 = 0 ;
26763 bool val2 ;
26764 int ecode2 = 0 ;
26765 int val3 ;
26766 int ecode3 = 0 ;
26767 PyObject * obj0 = 0 ;
26768 PyObject * obj1 = 0 ;
26769 PyObject * obj2 = 0 ;
26770 char * kwnames[] = {
26771 (char *) "type",(char *) "active",(char *) "Id", NULL
26772 };
26773
26774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26775 if (obj0) {
26776 ecode1 = SWIG_AsVal_int(obj0, &val1);
26777 if (!SWIG_IsOK(ecode1)) {
26778 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26779 }
26780 arg1 = static_cast< wxEventType >(val1);
26781 }
26782 if (obj1) {
26783 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26784 if (!SWIG_IsOK(ecode2)) {
26785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26786 }
26787 arg2 = static_cast< bool >(val2);
26788 }
26789 if (obj2) {
26790 ecode3 = SWIG_AsVal_int(obj2, &val3);
26791 if (!SWIG_IsOK(ecode3)) {
26792 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26793 }
26794 arg3 = static_cast< int >(val3);
26795 }
26796 {
26797 PyThreadState* __tstate = wxPyBeginAllowThreads();
26798 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26799 wxPyEndAllowThreads(__tstate);
26800 if (PyErr_Occurred()) SWIG_fail;
26801 }
26802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26803 return resultobj;
26804 fail:
26805 return NULL;
26806 }
26807
26808
26809 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26810 PyObject *resultobj = 0;
26811 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26812 bool result;
26813 void *argp1 = 0 ;
26814 int res1 = 0 ;
26815 PyObject *swig_obj[1] ;
26816
26817 if (!args) SWIG_fail;
26818 swig_obj[0] = args;
26819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26820 if (!SWIG_IsOK(res1)) {
26821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26822 }
26823 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26824 {
26825 PyThreadState* __tstate = wxPyBeginAllowThreads();
26826 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26827 wxPyEndAllowThreads(__tstate);
26828 if (PyErr_Occurred()) SWIG_fail;
26829 }
26830 {
26831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26832 }
26833 return resultobj;
26834 fail:
26835 return NULL;
26836 }
26837
26838
26839 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26840 PyObject *obj;
26841 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26842 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26843 return SWIG_Py_Void();
26844 }
26845
26846 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26847 return SWIG_Python_InitShadowInstance(args);
26848 }
26849
26850 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26851 PyObject *resultobj = 0;
26852 int arg1 = (int) 0 ;
26853 wxInitDialogEvent *result = 0 ;
26854 int val1 ;
26855 int ecode1 = 0 ;
26856 PyObject * obj0 = 0 ;
26857 char * kwnames[] = {
26858 (char *) "Id", NULL
26859 };
26860
26861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26862 if (obj0) {
26863 ecode1 = SWIG_AsVal_int(obj0, &val1);
26864 if (!SWIG_IsOK(ecode1)) {
26865 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26866 }
26867 arg1 = static_cast< int >(val1);
26868 }
26869 {
26870 PyThreadState* __tstate = wxPyBeginAllowThreads();
26871 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26872 wxPyEndAllowThreads(__tstate);
26873 if (PyErr_Occurred()) SWIG_fail;
26874 }
26875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26876 return resultobj;
26877 fail:
26878 return NULL;
26879 }
26880
26881
26882 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26883 PyObject *obj;
26884 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26885 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26886 return SWIG_Py_Void();
26887 }
26888
26889 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26890 return SWIG_Python_InitShadowInstance(args);
26891 }
26892
26893 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26894 PyObject *resultobj = 0;
26895 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26896 int arg2 = (int) 0 ;
26897 wxMenu *arg3 = (wxMenu *) NULL ;
26898 wxMenuEvent *result = 0 ;
26899 int val1 ;
26900 int ecode1 = 0 ;
26901 int val2 ;
26902 int ecode2 = 0 ;
26903 void *argp3 = 0 ;
26904 int res3 = 0 ;
26905 PyObject * obj0 = 0 ;
26906 PyObject * obj1 = 0 ;
26907 PyObject * obj2 = 0 ;
26908 char * kwnames[] = {
26909 (char *) "type",(char *) "winid",(char *) "menu", NULL
26910 };
26911
26912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26913 if (obj0) {
26914 ecode1 = SWIG_AsVal_int(obj0, &val1);
26915 if (!SWIG_IsOK(ecode1)) {
26916 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26917 }
26918 arg1 = static_cast< wxEventType >(val1);
26919 }
26920 if (obj1) {
26921 ecode2 = SWIG_AsVal_int(obj1, &val2);
26922 if (!SWIG_IsOK(ecode2)) {
26923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
26924 }
26925 arg2 = static_cast< int >(val2);
26926 }
26927 if (obj2) {
26928 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
26929 if (!SWIG_IsOK(res3)) {
26930 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
26931 }
26932 arg3 = reinterpret_cast< wxMenu * >(argp3);
26933 }
26934 {
26935 PyThreadState* __tstate = wxPyBeginAllowThreads();
26936 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
26937 wxPyEndAllowThreads(__tstate);
26938 if (PyErr_Occurred()) SWIG_fail;
26939 }
26940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
26941 return resultobj;
26942 fail:
26943 return NULL;
26944 }
26945
26946
26947 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26948 PyObject *resultobj = 0;
26949 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26950 int result;
26951 void *argp1 = 0 ;
26952 int res1 = 0 ;
26953 PyObject *swig_obj[1] ;
26954
26955 if (!args) SWIG_fail;
26956 swig_obj[0] = args;
26957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26958 if (!SWIG_IsOK(res1)) {
26959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26960 }
26961 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
26962 {
26963 PyThreadState* __tstate = wxPyBeginAllowThreads();
26964 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
26965 wxPyEndAllowThreads(__tstate);
26966 if (PyErr_Occurred()) SWIG_fail;
26967 }
26968 resultobj = SWIG_From_int(static_cast< int >(result));
26969 return resultobj;
26970 fail:
26971 return NULL;
26972 }
26973
26974
26975 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26976 PyObject *resultobj = 0;
26977 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26978 bool result;
26979 void *argp1 = 0 ;
26980 int res1 = 0 ;
26981 PyObject *swig_obj[1] ;
26982
26983 if (!args) SWIG_fail;
26984 swig_obj[0] = args;
26985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26986 if (!SWIG_IsOK(res1)) {
26987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26988 }
26989 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
26990 {
26991 PyThreadState* __tstate = wxPyBeginAllowThreads();
26992 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
26993 wxPyEndAllowThreads(__tstate);
26994 if (PyErr_Occurred()) SWIG_fail;
26995 }
26996 {
26997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26998 }
26999 return resultobj;
27000 fail:
27001 return NULL;
27002 }
27003
27004
27005 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27006 PyObject *resultobj = 0;
27007 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27008 wxMenu *result = 0 ;
27009 void *argp1 = 0 ;
27010 int res1 = 0 ;
27011 PyObject *swig_obj[1] ;
27012
27013 if (!args) SWIG_fail;
27014 swig_obj[0] = args;
27015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27016 if (!SWIG_IsOK(res1)) {
27017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27018 }
27019 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27020 {
27021 PyThreadState* __tstate = wxPyBeginAllowThreads();
27022 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27023 wxPyEndAllowThreads(__tstate);
27024 if (PyErr_Occurred()) SWIG_fail;
27025 }
27026 {
27027 resultobj = wxPyMake_wxObject(result, (bool)0);
27028 }
27029 return resultobj;
27030 fail:
27031 return NULL;
27032 }
27033
27034
27035 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27036 PyObject *obj;
27037 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27038 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27039 return SWIG_Py_Void();
27040 }
27041
27042 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27043 return SWIG_Python_InitShadowInstance(args);
27044 }
27045
27046 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27047 PyObject *resultobj = 0;
27048 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27049 int arg2 = (int) 0 ;
27050 wxCloseEvent *result = 0 ;
27051 int val1 ;
27052 int ecode1 = 0 ;
27053 int val2 ;
27054 int ecode2 = 0 ;
27055 PyObject * obj0 = 0 ;
27056 PyObject * obj1 = 0 ;
27057 char * kwnames[] = {
27058 (char *) "type",(char *) "winid", NULL
27059 };
27060
27061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27062 if (obj0) {
27063 ecode1 = SWIG_AsVal_int(obj0, &val1);
27064 if (!SWIG_IsOK(ecode1)) {
27065 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27066 }
27067 arg1 = static_cast< wxEventType >(val1);
27068 }
27069 if (obj1) {
27070 ecode2 = SWIG_AsVal_int(obj1, &val2);
27071 if (!SWIG_IsOK(ecode2)) {
27072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27073 }
27074 arg2 = static_cast< int >(val2);
27075 }
27076 {
27077 PyThreadState* __tstate = wxPyBeginAllowThreads();
27078 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27079 wxPyEndAllowThreads(__tstate);
27080 if (PyErr_Occurred()) SWIG_fail;
27081 }
27082 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27083 return resultobj;
27084 fail:
27085 return NULL;
27086 }
27087
27088
27089 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27090 PyObject *resultobj = 0;
27091 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27092 bool arg2 ;
27093 void *argp1 = 0 ;
27094 int res1 = 0 ;
27095 bool val2 ;
27096 int ecode2 = 0 ;
27097 PyObject * obj0 = 0 ;
27098 PyObject * obj1 = 0 ;
27099 char * kwnames[] = {
27100 (char *) "self",(char *) "logOff", NULL
27101 };
27102
27103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27105 if (!SWIG_IsOK(res1)) {
27106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27107 }
27108 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27109 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27110 if (!SWIG_IsOK(ecode2)) {
27111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27112 }
27113 arg2 = static_cast< bool >(val2);
27114 {
27115 PyThreadState* __tstate = wxPyBeginAllowThreads();
27116 (arg1)->SetLoggingOff(arg2);
27117 wxPyEndAllowThreads(__tstate);
27118 if (PyErr_Occurred()) SWIG_fail;
27119 }
27120 resultobj = SWIG_Py_Void();
27121 return resultobj;
27122 fail:
27123 return NULL;
27124 }
27125
27126
27127 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27128 PyObject *resultobj = 0;
27129 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27130 bool result;
27131 void *argp1 = 0 ;
27132 int res1 = 0 ;
27133 PyObject *swig_obj[1] ;
27134
27135 if (!args) SWIG_fail;
27136 swig_obj[0] = args;
27137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27138 if (!SWIG_IsOK(res1)) {
27139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27140 }
27141 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27142 {
27143 PyThreadState* __tstate = wxPyBeginAllowThreads();
27144 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27145 wxPyEndAllowThreads(__tstate);
27146 if (PyErr_Occurred()) SWIG_fail;
27147 }
27148 {
27149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27150 }
27151 return resultobj;
27152 fail:
27153 return NULL;
27154 }
27155
27156
27157 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27158 PyObject *resultobj = 0;
27159 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27160 bool arg2 = (bool) true ;
27161 void *argp1 = 0 ;
27162 int res1 = 0 ;
27163 bool val2 ;
27164 int ecode2 = 0 ;
27165 PyObject * obj0 = 0 ;
27166 PyObject * obj1 = 0 ;
27167 char * kwnames[] = {
27168 (char *) "self",(char *) "veto", NULL
27169 };
27170
27171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27173 if (!SWIG_IsOK(res1)) {
27174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27175 }
27176 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27177 if (obj1) {
27178 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27179 if (!SWIG_IsOK(ecode2)) {
27180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27181 }
27182 arg2 = static_cast< bool >(val2);
27183 }
27184 {
27185 PyThreadState* __tstate = wxPyBeginAllowThreads();
27186 (arg1)->Veto(arg2);
27187 wxPyEndAllowThreads(__tstate);
27188 if (PyErr_Occurred()) SWIG_fail;
27189 }
27190 resultobj = SWIG_Py_Void();
27191 return resultobj;
27192 fail:
27193 return NULL;
27194 }
27195
27196
27197 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27198 PyObject *resultobj = 0;
27199 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27200 bool result;
27201 void *argp1 = 0 ;
27202 int res1 = 0 ;
27203 PyObject *swig_obj[1] ;
27204
27205 if (!args) SWIG_fail;
27206 swig_obj[0] = args;
27207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27208 if (!SWIG_IsOK(res1)) {
27209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27210 }
27211 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27212 {
27213 PyThreadState* __tstate = wxPyBeginAllowThreads();
27214 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27215 wxPyEndAllowThreads(__tstate);
27216 if (PyErr_Occurred()) SWIG_fail;
27217 }
27218 {
27219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27220 }
27221 return resultobj;
27222 fail:
27223 return NULL;
27224 }
27225
27226
27227 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27228 PyObject *resultobj = 0;
27229 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27230 bool arg2 ;
27231 void *argp1 = 0 ;
27232 int res1 = 0 ;
27233 bool val2 ;
27234 int ecode2 = 0 ;
27235 PyObject * obj0 = 0 ;
27236 PyObject * obj1 = 0 ;
27237 char * kwnames[] = {
27238 (char *) "self",(char *) "canVeto", NULL
27239 };
27240
27241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27243 if (!SWIG_IsOK(res1)) {
27244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27245 }
27246 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27247 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27248 if (!SWIG_IsOK(ecode2)) {
27249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27250 }
27251 arg2 = static_cast< bool >(val2);
27252 {
27253 PyThreadState* __tstate = wxPyBeginAllowThreads();
27254 (arg1)->SetCanVeto(arg2);
27255 wxPyEndAllowThreads(__tstate);
27256 if (PyErr_Occurred()) SWIG_fail;
27257 }
27258 resultobj = SWIG_Py_Void();
27259 return resultobj;
27260 fail:
27261 return NULL;
27262 }
27263
27264
27265 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27266 PyObject *resultobj = 0;
27267 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27268 bool result;
27269 void *argp1 = 0 ;
27270 int res1 = 0 ;
27271 PyObject *swig_obj[1] ;
27272
27273 if (!args) SWIG_fail;
27274 swig_obj[0] = args;
27275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27276 if (!SWIG_IsOK(res1)) {
27277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27278 }
27279 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27280 {
27281 PyThreadState* __tstate = wxPyBeginAllowThreads();
27282 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27283 wxPyEndAllowThreads(__tstate);
27284 if (PyErr_Occurred()) SWIG_fail;
27285 }
27286 {
27287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27288 }
27289 return resultobj;
27290 fail:
27291 return NULL;
27292 }
27293
27294
27295 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27296 PyObject *obj;
27297 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27298 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27299 return SWIG_Py_Void();
27300 }
27301
27302 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27303 return SWIG_Python_InitShadowInstance(args);
27304 }
27305
27306 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27307 PyObject *resultobj = 0;
27308 int arg1 = (int) 0 ;
27309 bool arg2 = (bool) false ;
27310 wxShowEvent *result = 0 ;
27311 int val1 ;
27312 int ecode1 = 0 ;
27313 bool val2 ;
27314 int ecode2 = 0 ;
27315 PyObject * obj0 = 0 ;
27316 PyObject * obj1 = 0 ;
27317 char * kwnames[] = {
27318 (char *) "winid",(char *) "show", NULL
27319 };
27320
27321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27322 if (obj0) {
27323 ecode1 = SWIG_AsVal_int(obj0, &val1);
27324 if (!SWIG_IsOK(ecode1)) {
27325 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27326 }
27327 arg1 = static_cast< int >(val1);
27328 }
27329 if (obj1) {
27330 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27331 if (!SWIG_IsOK(ecode2)) {
27332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27333 }
27334 arg2 = static_cast< bool >(val2);
27335 }
27336 {
27337 PyThreadState* __tstate = wxPyBeginAllowThreads();
27338 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27339 wxPyEndAllowThreads(__tstate);
27340 if (PyErr_Occurred()) SWIG_fail;
27341 }
27342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27343 return resultobj;
27344 fail:
27345 return NULL;
27346 }
27347
27348
27349 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27350 PyObject *resultobj = 0;
27351 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27352 bool arg2 ;
27353 void *argp1 = 0 ;
27354 int res1 = 0 ;
27355 bool val2 ;
27356 int ecode2 = 0 ;
27357 PyObject * obj0 = 0 ;
27358 PyObject * obj1 = 0 ;
27359 char * kwnames[] = {
27360 (char *) "self",(char *) "show", NULL
27361 };
27362
27363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27365 if (!SWIG_IsOK(res1)) {
27366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27367 }
27368 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27369 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27370 if (!SWIG_IsOK(ecode2)) {
27371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27372 }
27373 arg2 = static_cast< bool >(val2);
27374 {
27375 PyThreadState* __tstate = wxPyBeginAllowThreads();
27376 (arg1)->SetShow(arg2);
27377 wxPyEndAllowThreads(__tstate);
27378 if (PyErr_Occurred()) SWIG_fail;
27379 }
27380 resultobj = SWIG_Py_Void();
27381 return resultobj;
27382 fail:
27383 return NULL;
27384 }
27385
27386
27387 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27388 PyObject *resultobj = 0;
27389 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27390 bool result;
27391 void *argp1 = 0 ;
27392 int res1 = 0 ;
27393 PyObject *swig_obj[1] ;
27394
27395 if (!args) SWIG_fail;
27396 swig_obj[0] = args;
27397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27398 if (!SWIG_IsOK(res1)) {
27399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27400 }
27401 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27402 {
27403 PyThreadState* __tstate = wxPyBeginAllowThreads();
27404 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27405 wxPyEndAllowThreads(__tstate);
27406 if (PyErr_Occurred()) SWIG_fail;
27407 }
27408 {
27409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27410 }
27411 return resultobj;
27412 fail:
27413 return NULL;
27414 }
27415
27416
27417 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27418 PyObject *obj;
27419 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27420 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27421 return SWIG_Py_Void();
27422 }
27423
27424 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27425 return SWIG_Python_InitShadowInstance(args);
27426 }
27427
27428 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27429 PyObject *resultobj = 0;
27430 int arg1 = (int) 0 ;
27431 bool arg2 = (bool) true ;
27432 wxIconizeEvent *result = 0 ;
27433 int val1 ;
27434 int ecode1 = 0 ;
27435 bool val2 ;
27436 int ecode2 = 0 ;
27437 PyObject * obj0 = 0 ;
27438 PyObject * obj1 = 0 ;
27439 char * kwnames[] = {
27440 (char *) "id",(char *) "iconized", NULL
27441 };
27442
27443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27444 if (obj0) {
27445 ecode1 = SWIG_AsVal_int(obj0, &val1);
27446 if (!SWIG_IsOK(ecode1)) {
27447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27448 }
27449 arg1 = static_cast< int >(val1);
27450 }
27451 if (obj1) {
27452 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27453 if (!SWIG_IsOK(ecode2)) {
27454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27455 }
27456 arg2 = static_cast< bool >(val2);
27457 }
27458 {
27459 PyThreadState* __tstate = wxPyBeginAllowThreads();
27460 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27461 wxPyEndAllowThreads(__tstate);
27462 if (PyErr_Occurred()) SWIG_fail;
27463 }
27464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27465 return resultobj;
27466 fail:
27467 return NULL;
27468 }
27469
27470
27471 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27472 PyObject *resultobj = 0;
27473 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27474 bool result;
27475 void *argp1 = 0 ;
27476 int res1 = 0 ;
27477 PyObject *swig_obj[1] ;
27478
27479 if (!args) SWIG_fail;
27480 swig_obj[0] = args;
27481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27482 if (!SWIG_IsOK(res1)) {
27483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27484 }
27485 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27486 {
27487 PyThreadState* __tstate = wxPyBeginAllowThreads();
27488 result = (bool)(arg1)->Iconized();
27489 wxPyEndAllowThreads(__tstate);
27490 if (PyErr_Occurred()) SWIG_fail;
27491 }
27492 {
27493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27494 }
27495 return resultobj;
27496 fail:
27497 return NULL;
27498 }
27499
27500
27501 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27502 PyObject *obj;
27503 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27504 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27505 return SWIG_Py_Void();
27506 }
27507
27508 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27509 return SWIG_Python_InitShadowInstance(args);
27510 }
27511
27512 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27513 PyObject *resultobj = 0;
27514 int arg1 = (int) 0 ;
27515 wxMaximizeEvent *result = 0 ;
27516 int val1 ;
27517 int ecode1 = 0 ;
27518 PyObject * obj0 = 0 ;
27519 char * kwnames[] = {
27520 (char *) "id", NULL
27521 };
27522
27523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27524 if (obj0) {
27525 ecode1 = SWIG_AsVal_int(obj0, &val1);
27526 if (!SWIG_IsOK(ecode1)) {
27527 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27528 }
27529 arg1 = static_cast< int >(val1);
27530 }
27531 {
27532 PyThreadState* __tstate = wxPyBeginAllowThreads();
27533 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27534 wxPyEndAllowThreads(__tstate);
27535 if (PyErr_Occurred()) SWIG_fail;
27536 }
27537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27538 return resultobj;
27539 fail:
27540 return NULL;
27541 }
27542
27543
27544 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27545 PyObject *obj;
27546 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27547 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27548 return SWIG_Py_Void();
27549 }
27550
27551 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27552 return SWIG_Python_InitShadowInstance(args);
27553 }
27554
27555 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27556 PyObject *resultobj = 0;
27557 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27558 wxPoint result;
27559 void *argp1 = 0 ;
27560 int res1 = 0 ;
27561 PyObject *swig_obj[1] ;
27562
27563 if (!args) SWIG_fail;
27564 swig_obj[0] = args;
27565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27566 if (!SWIG_IsOK(res1)) {
27567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27568 }
27569 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27570 {
27571 PyThreadState* __tstate = wxPyBeginAllowThreads();
27572 result = (arg1)->GetPosition();
27573 wxPyEndAllowThreads(__tstate);
27574 if (PyErr_Occurred()) SWIG_fail;
27575 }
27576 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27577 return resultobj;
27578 fail:
27579 return NULL;
27580 }
27581
27582
27583 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27584 PyObject *resultobj = 0;
27585 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27586 int result;
27587 void *argp1 = 0 ;
27588 int res1 = 0 ;
27589 PyObject *swig_obj[1] ;
27590
27591 if (!args) SWIG_fail;
27592 swig_obj[0] = args;
27593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27594 if (!SWIG_IsOK(res1)) {
27595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27596 }
27597 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27598 {
27599 PyThreadState* __tstate = wxPyBeginAllowThreads();
27600 result = (int)(arg1)->GetNumberOfFiles();
27601 wxPyEndAllowThreads(__tstate);
27602 if (PyErr_Occurred()) SWIG_fail;
27603 }
27604 resultobj = SWIG_From_int(static_cast< int >(result));
27605 return resultobj;
27606 fail:
27607 return NULL;
27608 }
27609
27610
27611 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27612 PyObject *resultobj = 0;
27613 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27614 PyObject *result = 0 ;
27615 void *argp1 = 0 ;
27616 int res1 = 0 ;
27617 PyObject *swig_obj[1] ;
27618
27619 if (!args) SWIG_fail;
27620 swig_obj[0] = args;
27621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27622 if (!SWIG_IsOK(res1)) {
27623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27624 }
27625 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27626 {
27627 PyThreadState* __tstate = wxPyBeginAllowThreads();
27628 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27629 wxPyEndAllowThreads(__tstate);
27630 if (PyErr_Occurred()) SWIG_fail;
27631 }
27632 resultobj = result;
27633 return resultobj;
27634 fail:
27635 return NULL;
27636 }
27637
27638
27639 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27640 PyObject *obj;
27641 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27642 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27643 return SWIG_Py_Void();
27644 }
27645
27646 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27647 PyObject *resultobj = 0;
27648 int arg1 = (int) 0 ;
27649 wxUpdateUIEvent *result = 0 ;
27650 int val1 ;
27651 int ecode1 = 0 ;
27652 PyObject * obj0 = 0 ;
27653 char * kwnames[] = {
27654 (char *) "commandId", NULL
27655 };
27656
27657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27658 if (obj0) {
27659 ecode1 = SWIG_AsVal_int(obj0, &val1);
27660 if (!SWIG_IsOK(ecode1)) {
27661 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27662 }
27663 arg1 = static_cast< int >(val1);
27664 }
27665 {
27666 PyThreadState* __tstate = wxPyBeginAllowThreads();
27667 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27668 wxPyEndAllowThreads(__tstate);
27669 if (PyErr_Occurred()) SWIG_fail;
27670 }
27671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27672 return resultobj;
27673 fail:
27674 return NULL;
27675 }
27676
27677
27678 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27679 PyObject *resultobj = 0;
27680 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27681 bool result;
27682 void *argp1 = 0 ;
27683 int res1 = 0 ;
27684 PyObject *swig_obj[1] ;
27685
27686 if (!args) SWIG_fail;
27687 swig_obj[0] = args;
27688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27689 if (!SWIG_IsOK(res1)) {
27690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27691 }
27692 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27693 {
27694 PyThreadState* __tstate = wxPyBeginAllowThreads();
27695 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27696 wxPyEndAllowThreads(__tstate);
27697 if (PyErr_Occurred()) SWIG_fail;
27698 }
27699 {
27700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27701 }
27702 return resultobj;
27703 fail:
27704 return NULL;
27705 }
27706
27707
27708 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27709 PyObject *resultobj = 0;
27710 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27711 bool result;
27712 void *argp1 = 0 ;
27713 int res1 = 0 ;
27714 PyObject *swig_obj[1] ;
27715
27716 if (!args) SWIG_fail;
27717 swig_obj[0] = args;
27718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27719 if (!SWIG_IsOK(res1)) {
27720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27721 }
27722 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27723 {
27724 PyThreadState* __tstate = wxPyBeginAllowThreads();
27725 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27726 wxPyEndAllowThreads(__tstate);
27727 if (PyErr_Occurred()) SWIG_fail;
27728 }
27729 {
27730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27731 }
27732 return resultobj;
27733 fail:
27734 return NULL;
27735 }
27736
27737
27738 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27739 PyObject *resultobj = 0;
27740 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27741 bool result;
27742 void *argp1 = 0 ;
27743 int res1 = 0 ;
27744 PyObject *swig_obj[1] ;
27745
27746 if (!args) SWIG_fail;
27747 swig_obj[0] = args;
27748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27749 if (!SWIG_IsOK(res1)) {
27750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27751 }
27752 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27753 {
27754 PyThreadState* __tstate = wxPyBeginAllowThreads();
27755 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27756 wxPyEndAllowThreads(__tstate);
27757 if (PyErr_Occurred()) SWIG_fail;
27758 }
27759 {
27760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27761 }
27762 return resultobj;
27763 fail:
27764 return NULL;
27765 }
27766
27767
27768 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27769 PyObject *resultobj = 0;
27770 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27771 wxString result;
27772 void *argp1 = 0 ;
27773 int res1 = 0 ;
27774 PyObject *swig_obj[1] ;
27775
27776 if (!args) SWIG_fail;
27777 swig_obj[0] = args;
27778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27779 if (!SWIG_IsOK(res1)) {
27780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27781 }
27782 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27783 {
27784 PyThreadState* __tstate = wxPyBeginAllowThreads();
27785 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27786 wxPyEndAllowThreads(__tstate);
27787 if (PyErr_Occurred()) SWIG_fail;
27788 }
27789 {
27790 #if wxUSE_UNICODE
27791 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27792 #else
27793 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27794 #endif
27795 }
27796 return resultobj;
27797 fail:
27798 return NULL;
27799 }
27800
27801
27802 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27803 PyObject *resultobj = 0;
27804 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27805 bool result;
27806 void *argp1 = 0 ;
27807 int res1 = 0 ;
27808 PyObject *swig_obj[1] ;
27809
27810 if (!args) SWIG_fail;
27811 swig_obj[0] = args;
27812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27813 if (!SWIG_IsOK(res1)) {
27814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27815 }
27816 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27817 {
27818 PyThreadState* __tstate = wxPyBeginAllowThreads();
27819 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27820 wxPyEndAllowThreads(__tstate);
27821 if (PyErr_Occurred()) SWIG_fail;
27822 }
27823 {
27824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27825 }
27826 return resultobj;
27827 fail:
27828 return NULL;
27829 }
27830
27831
27832 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27833 PyObject *resultobj = 0;
27834 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27835 bool result;
27836 void *argp1 = 0 ;
27837 int res1 = 0 ;
27838 PyObject *swig_obj[1] ;
27839
27840 if (!args) SWIG_fail;
27841 swig_obj[0] = args;
27842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27843 if (!SWIG_IsOK(res1)) {
27844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27845 }
27846 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27847 {
27848 PyThreadState* __tstate = wxPyBeginAllowThreads();
27849 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27850 wxPyEndAllowThreads(__tstate);
27851 if (PyErr_Occurred()) SWIG_fail;
27852 }
27853 {
27854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27855 }
27856 return resultobj;
27857 fail:
27858 return NULL;
27859 }
27860
27861
27862 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27863 PyObject *resultobj = 0;
27864 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27865 bool result;
27866 void *argp1 = 0 ;
27867 int res1 = 0 ;
27868 PyObject *swig_obj[1] ;
27869
27870 if (!args) SWIG_fail;
27871 swig_obj[0] = args;
27872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27873 if (!SWIG_IsOK(res1)) {
27874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27875 }
27876 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27877 {
27878 PyThreadState* __tstate = wxPyBeginAllowThreads();
27879 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27880 wxPyEndAllowThreads(__tstate);
27881 if (PyErr_Occurred()) SWIG_fail;
27882 }
27883 {
27884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27885 }
27886 return resultobj;
27887 fail:
27888 return NULL;
27889 }
27890
27891
27892 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27893 PyObject *resultobj = 0;
27894 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27895 bool result;
27896 void *argp1 = 0 ;
27897 int res1 = 0 ;
27898 PyObject *swig_obj[1] ;
27899
27900 if (!args) SWIG_fail;
27901 swig_obj[0] = args;
27902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27903 if (!SWIG_IsOK(res1)) {
27904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27905 }
27906 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27907 {
27908 PyThreadState* __tstate = wxPyBeginAllowThreads();
27909 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
27910 wxPyEndAllowThreads(__tstate);
27911 if (PyErr_Occurred()) SWIG_fail;
27912 }
27913 {
27914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27915 }
27916 return resultobj;
27917 fail:
27918 return NULL;
27919 }
27920
27921
27922 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27923 PyObject *resultobj = 0;
27924 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27925 bool arg2 ;
27926 void *argp1 = 0 ;
27927 int res1 = 0 ;
27928 bool val2 ;
27929 int ecode2 = 0 ;
27930 PyObject * obj0 = 0 ;
27931 PyObject * obj1 = 0 ;
27932 char * kwnames[] = {
27933 (char *) "self",(char *) "check", NULL
27934 };
27935
27936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
27937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27938 if (!SWIG_IsOK(res1)) {
27939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27940 }
27941 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27942 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27943 if (!SWIG_IsOK(ecode2)) {
27944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
27945 }
27946 arg2 = static_cast< bool >(val2);
27947 {
27948 PyThreadState* __tstate = wxPyBeginAllowThreads();
27949 (arg1)->Check(arg2);
27950 wxPyEndAllowThreads(__tstate);
27951 if (PyErr_Occurred()) SWIG_fail;
27952 }
27953 resultobj = SWIG_Py_Void();
27954 return resultobj;
27955 fail:
27956 return NULL;
27957 }
27958
27959
27960 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27961 PyObject *resultobj = 0;
27962 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27963 bool arg2 ;
27964 void *argp1 = 0 ;
27965 int res1 = 0 ;
27966 bool val2 ;
27967 int ecode2 = 0 ;
27968 PyObject * obj0 = 0 ;
27969 PyObject * obj1 = 0 ;
27970 char * kwnames[] = {
27971 (char *) "self",(char *) "enable", NULL
27972 };
27973
27974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
27975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27976 if (!SWIG_IsOK(res1)) {
27977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27978 }
27979 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27980 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27981 if (!SWIG_IsOK(ecode2)) {
27982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
27983 }
27984 arg2 = static_cast< bool >(val2);
27985 {
27986 PyThreadState* __tstate = wxPyBeginAllowThreads();
27987 (arg1)->Enable(arg2);
27988 wxPyEndAllowThreads(__tstate);
27989 if (PyErr_Occurred()) SWIG_fail;
27990 }
27991 resultobj = SWIG_Py_Void();
27992 return resultobj;
27993 fail:
27994 return NULL;
27995 }
27996
27997
27998 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27999 PyObject *resultobj = 0;
28000 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28001 bool arg2 ;
28002 void *argp1 = 0 ;
28003 int res1 = 0 ;
28004 bool val2 ;
28005 int ecode2 = 0 ;
28006 PyObject * obj0 = 0 ;
28007 PyObject * obj1 = 0 ;
28008 char * kwnames[] = {
28009 (char *) "self",(char *) "show", NULL
28010 };
28011
28012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28014 if (!SWIG_IsOK(res1)) {
28015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28016 }
28017 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28018 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28019 if (!SWIG_IsOK(ecode2)) {
28020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28021 }
28022 arg2 = static_cast< bool >(val2);
28023 {
28024 PyThreadState* __tstate = wxPyBeginAllowThreads();
28025 (arg1)->Show(arg2);
28026 wxPyEndAllowThreads(__tstate);
28027 if (PyErr_Occurred()) SWIG_fail;
28028 }
28029 resultobj = SWIG_Py_Void();
28030 return resultobj;
28031 fail:
28032 return NULL;
28033 }
28034
28035
28036 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28037 PyObject *resultobj = 0;
28038 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28039 wxString *arg2 = 0 ;
28040 void *argp1 = 0 ;
28041 int res1 = 0 ;
28042 bool temp2 = false ;
28043 PyObject * obj0 = 0 ;
28044 PyObject * obj1 = 0 ;
28045 char * kwnames[] = {
28046 (char *) "self",(char *) "text", NULL
28047 };
28048
28049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28051 if (!SWIG_IsOK(res1)) {
28052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28053 }
28054 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28055 {
28056 arg2 = wxString_in_helper(obj1);
28057 if (arg2 == NULL) SWIG_fail;
28058 temp2 = true;
28059 }
28060 {
28061 PyThreadState* __tstate = wxPyBeginAllowThreads();
28062 (arg1)->SetText((wxString const &)*arg2);
28063 wxPyEndAllowThreads(__tstate);
28064 if (PyErr_Occurred()) SWIG_fail;
28065 }
28066 resultobj = SWIG_Py_Void();
28067 {
28068 if (temp2)
28069 delete arg2;
28070 }
28071 return resultobj;
28072 fail:
28073 {
28074 if (temp2)
28075 delete arg2;
28076 }
28077 return NULL;
28078 }
28079
28080
28081 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28082 PyObject *resultobj = 0;
28083 long arg1 ;
28084 long val1 ;
28085 int ecode1 = 0 ;
28086 PyObject * obj0 = 0 ;
28087 char * kwnames[] = {
28088 (char *) "updateInterval", NULL
28089 };
28090
28091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28092 ecode1 = SWIG_AsVal_long(obj0, &val1);
28093 if (!SWIG_IsOK(ecode1)) {
28094 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28095 }
28096 arg1 = static_cast< long >(val1);
28097 {
28098 PyThreadState* __tstate = wxPyBeginAllowThreads();
28099 wxUpdateUIEvent::SetUpdateInterval(arg1);
28100 wxPyEndAllowThreads(__tstate);
28101 if (PyErr_Occurred()) SWIG_fail;
28102 }
28103 resultobj = SWIG_Py_Void();
28104 return resultobj;
28105 fail:
28106 return NULL;
28107 }
28108
28109
28110 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28111 PyObject *resultobj = 0;
28112 long result;
28113
28114 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28115 {
28116 PyThreadState* __tstate = wxPyBeginAllowThreads();
28117 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28118 wxPyEndAllowThreads(__tstate);
28119 if (PyErr_Occurred()) SWIG_fail;
28120 }
28121 resultobj = SWIG_From_long(static_cast< long >(result));
28122 return resultobj;
28123 fail:
28124 return NULL;
28125 }
28126
28127
28128 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28129 PyObject *resultobj = 0;
28130 wxWindow *arg1 = (wxWindow *) 0 ;
28131 bool result;
28132 void *argp1 = 0 ;
28133 int res1 = 0 ;
28134 PyObject * obj0 = 0 ;
28135 char * kwnames[] = {
28136 (char *) "win", NULL
28137 };
28138
28139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28141 if (!SWIG_IsOK(res1)) {
28142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28143 }
28144 arg1 = reinterpret_cast< wxWindow * >(argp1);
28145 {
28146 PyThreadState* __tstate = wxPyBeginAllowThreads();
28147 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28148 wxPyEndAllowThreads(__tstate);
28149 if (PyErr_Occurred()) SWIG_fail;
28150 }
28151 {
28152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28153 }
28154 return resultobj;
28155 fail:
28156 return NULL;
28157 }
28158
28159
28160 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28161 PyObject *resultobj = 0;
28162
28163 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28164 {
28165 PyThreadState* __tstate = wxPyBeginAllowThreads();
28166 wxUpdateUIEvent::ResetUpdateTime();
28167 wxPyEndAllowThreads(__tstate);
28168 if (PyErr_Occurred()) SWIG_fail;
28169 }
28170 resultobj = SWIG_Py_Void();
28171 return resultobj;
28172 fail:
28173 return NULL;
28174 }
28175
28176
28177 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28178 PyObject *resultobj = 0;
28179 wxUpdateUIMode arg1 ;
28180 int val1 ;
28181 int ecode1 = 0 ;
28182 PyObject * obj0 = 0 ;
28183 char * kwnames[] = {
28184 (char *) "mode", NULL
28185 };
28186
28187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28188 ecode1 = SWIG_AsVal_int(obj0, &val1);
28189 if (!SWIG_IsOK(ecode1)) {
28190 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28191 }
28192 arg1 = static_cast< wxUpdateUIMode >(val1);
28193 {
28194 PyThreadState* __tstate = wxPyBeginAllowThreads();
28195 wxUpdateUIEvent::SetMode(arg1);
28196 wxPyEndAllowThreads(__tstate);
28197 if (PyErr_Occurred()) SWIG_fail;
28198 }
28199 resultobj = SWIG_Py_Void();
28200 return resultobj;
28201 fail:
28202 return NULL;
28203 }
28204
28205
28206 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28207 PyObject *resultobj = 0;
28208 wxUpdateUIMode result;
28209
28210 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28211 {
28212 PyThreadState* __tstate = wxPyBeginAllowThreads();
28213 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28214 wxPyEndAllowThreads(__tstate);
28215 if (PyErr_Occurred()) SWIG_fail;
28216 }
28217 resultobj = SWIG_From_int(static_cast< int >(result));
28218 return resultobj;
28219 fail:
28220 return NULL;
28221 }
28222
28223
28224 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28225 PyObject *obj;
28226 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28227 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28228 return SWIG_Py_Void();
28229 }
28230
28231 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28232 return SWIG_Python_InitShadowInstance(args);
28233 }
28234
28235 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28236 PyObject *resultobj = 0;
28237 wxSysColourChangedEvent *result = 0 ;
28238
28239 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28240 {
28241 PyThreadState* __tstate = wxPyBeginAllowThreads();
28242 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28243 wxPyEndAllowThreads(__tstate);
28244 if (PyErr_Occurred()) SWIG_fail;
28245 }
28246 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28247 return resultobj;
28248 fail:
28249 return NULL;
28250 }
28251
28252
28253 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28254 PyObject *obj;
28255 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28256 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28257 return SWIG_Py_Void();
28258 }
28259
28260 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28261 return SWIG_Python_InitShadowInstance(args);
28262 }
28263
28264 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28265 PyObject *resultobj = 0;
28266 int arg1 = (int) 0 ;
28267 wxWindow *arg2 = (wxWindow *) NULL ;
28268 wxMouseCaptureChangedEvent *result = 0 ;
28269 int val1 ;
28270 int ecode1 = 0 ;
28271 void *argp2 = 0 ;
28272 int res2 = 0 ;
28273 PyObject * obj0 = 0 ;
28274 PyObject * obj1 = 0 ;
28275 char * kwnames[] = {
28276 (char *) "winid",(char *) "gainedCapture", NULL
28277 };
28278
28279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28280 if (obj0) {
28281 ecode1 = SWIG_AsVal_int(obj0, &val1);
28282 if (!SWIG_IsOK(ecode1)) {
28283 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28284 }
28285 arg1 = static_cast< int >(val1);
28286 }
28287 if (obj1) {
28288 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28289 if (!SWIG_IsOK(res2)) {
28290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28291 }
28292 arg2 = reinterpret_cast< wxWindow * >(argp2);
28293 }
28294 {
28295 PyThreadState* __tstate = wxPyBeginAllowThreads();
28296 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28297 wxPyEndAllowThreads(__tstate);
28298 if (PyErr_Occurred()) SWIG_fail;
28299 }
28300 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28301 return resultobj;
28302 fail:
28303 return NULL;
28304 }
28305
28306
28307 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28308 PyObject *resultobj = 0;
28309 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28310 wxWindow *result = 0 ;
28311 void *argp1 = 0 ;
28312 int res1 = 0 ;
28313 PyObject *swig_obj[1] ;
28314
28315 if (!args) SWIG_fail;
28316 swig_obj[0] = args;
28317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28318 if (!SWIG_IsOK(res1)) {
28319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28320 }
28321 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28322 {
28323 PyThreadState* __tstate = wxPyBeginAllowThreads();
28324 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28325 wxPyEndAllowThreads(__tstate);
28326 if (PyErr_Occurred()) SWIG_fail;
28327 }
28328 {
28329 resultobj = wxPyMake_wxObject(result, (bool)0);
28330 }
28331 return resultobj;
28332 fail:
28333 return NULL;
28334 }
28335
28336
28337 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28338 PyObject *obj;
28339 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28340 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28341 return SWIG_Py_Void();
28342 }
28343
28344 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28345 return SWIG_Python_InitShadowInstance(args);
28346 }
28347
28348 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28349 PyObject *resultobj = 0;
28350 int arg1 = (int) 0 ;
28351 wxMouseCaptureLostEvent *result = 0 ;
28352 int val1 ;
28353 int ecode1 = 0 ;
28354 PyObject * obj0 = 0 ;
28355 char * kwnames[] = {
28356 (char *) "winid", NULL
28357 };
28358
28359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28360 if (obj0) {
28361 ecode1 = SWIG_AsVal_int(obj0, &val1);
28362 if (!SWIG_IsOK(ecode1)) {
28363 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28364 }
28365 arg1 = static_cast< int >(val1);
28366 }
28367 {
28368 PyThreadState* __tstate = wxPyBeginAllowThreads();
28369 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28370 wxPyEndAllowThreads(__tstate);
28371 if (PyErr_Occurred()) SWIG_fail;
28372 }
28373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28374 return resultobj;
28375 fail:
28376 return NULL;
28377 }
28378
28379
28380 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28381 PyObject *obj;
28382 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28383 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28384 return SWIG_Py_Void();
28385 }
28386
28387 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28388 return SWIG_Python_InitShadowInstance(args);
28389 }
28390
28391 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28392 PyObject *resultobj = 0;
28393 wxDisplayChangedEvent *result = 0 ;
28394
28395 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28396 {
28397 PyThreadState* __tstate = wxPyBeginAllowThreads();
28398 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28399 wxPyEndAllowThreads(__tstate);
28400 if (PyErr_Occurred()) SWIG_fail;
28401 }
28402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28403 return resultobj;
28404 fail:
28405 return NULL;
28406 }
28407
28408
28409 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28410 PyObject *obj;
28411 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28412 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28413 return SWIG_Py_Void();
28414 }
28415
28416 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28417 return SWIG_Python_InitShadowInstance(args);
28418 }
28419
28420 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28421 PyObject *resultobj = 0;
28422 int arg1 = (int) 0 ;
28423 wxPaletteChangedEvent *result = 0 ;
28424 int val1 ;
28425 int ecode1 = 0 ;
28426 PyObject * obj0 = 0 ;
28427 char * kwnames[] = {
28428 (char *) "id", NULL
28429 };
28430
28431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28432 if (obj0) {
28433 ecode1 = SWIG_AsVal_int(obj0, &val1);
28434 if (!SWIG_IsOK(ecode1)) {
28435 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28436 }
28437 arg1 = static_cast< int >(val1);
28438 }
28439 {
28440 PyThreadState* __tstate = wxPyBeginAllowThreads();
28441 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28442 wxPyEndAllowThreads(__tstate);
28443 if (PyErr_Occurred()) SWIG_fail;
28444 }
28445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28446 return resultobj;
28447 fail:
28448 return NULL;
28449 }
28450
28451
28452 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28453 PyObject *resultobj = 0;
28454 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28455 wxWindow *arg2 = (wxWindow *) 0 ;
28456 void *argp1 = 0 ;
28457 int res1 = 0 ;
28458 void *argp2 = 0 ;
28459 int res2 = 0 ;
28460 PyObject * obj0 = 0 ;
28461 PyObject * obj1 = 0 ;
28462 char * kwnames[] = {
28463 (char *) "self",(char *) "win", NULL
28464 };
28465
28466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28468 if (!SWIG_IsOK(res1)) {
28469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28470 }
28471 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28472 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28473 if (!SWIG_IsOK(res2)) {
28474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28475 }
28476 arg2 = reinterpret_cast< wxWindow * >(argp2);
28477 {
28478 PyThreadState* __tstate = wxPyBeginAllowThreads();
28479 (arg1)->SetChangedWindow(arg2);
28480 wxPyEndAllowThreads(__tstate);
28481 if (PyErr_Occurred()) SWIG_fail;
28482 }
28483 resultobj = SWIG_Py_Void();
28484 return resultobj;
28485 fail:
28486 return NULL;
28487 }
28488
28489
28490 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28491 PyObject *resultobj = 0;
28492 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28493 wxWindow *result = 0 ;
28494 void *argp1 = 0 ;
28495 int res1 = 0 ;
28496 PyObject *swig_obj[1] ;
28497
28498 if (!args) SWIG_fail;
28499 swig_obj[0] = args;
28500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28501 if (!SWIG_IsOK(res1)) {
28502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28503 }
28504 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28505 {
28506 PyThreadState* __tstate = wxPyBeginAllowThreads();
28507 result = (wxWindow *)(arg1)->GetChangedWindow();
28508 wxPyEndAllowThreads(__tstate);
28509 if (PyErr_Occurred()) SWIG_fail;
28510 }
28511 {
28512 resultobj = wxPyMake_wxObject(result, (bool)0);
28513 }
28514 return resultobj;
28515 fail:
28516 return NULL;
28517 }
28518
28519
28520 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28521 PyObject *obj;
28522 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28523 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28524 return SWIG_Py_Void();
28525 }
28526
28527 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28528 return SWIG_Python_InitShadowInstance(args);
28529 }
28530
28531 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28532 PyObject *resultobj = 0;
28533 int arg1 = (int) 0 ;
28534 wxQueryNewPaletteEvent *result = 0 ;
28535 int val1 ;
28536 int ecode1 = 0 ;
28537 PyObject * obj0 = 0 ;
28538 char * kwnames[] = {
28539 (char *) "winid", NULL
28540 };
28541
28542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28543 if (obj0) {
28544 ecode1 = SWIG_AsVal_int(obj0, &val1);
28545 if (!SWIG_IsOK(ecode1)) {
28546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28547 }
28548 arg1 = static_cast< int >(val1);
28549 }
28550 {
28551 PyThreadState* __tstate = wxPyBeginAllowThreads();
28552 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28553 wxPyEndAllowThreads(__tstate);
28554 if (PyErr_Occurred()) SWIG_fail;
28555 }
28556 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28557 return resultobj;
28558 fail:
28559 return NULL;
28560 }
28561
28562
28563 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28564 PyObject *resultobj = 0;
28565 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28566 bool arg2 ;
28567 void *argp1 = 0 ;
28568 int res1 = 0 ;
28569 bool val2 ;
28570 int ecode2 = 0 ;
28571 PyObject * obj0 = 0 ;
28572 PyObject * obj1 = 0 ;
28573 char * kwnames[] = {
28574 (char *) "self",(char *) "realized", NULL
28575 };
28576
28577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28579 if (!SWIG_IsOK(res1)) {
28580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28581 }
28582 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28583 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28584 if (!SWIG_IsOK(ecode2)) {
28585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28586 }
28587 arg2 = static_cast< bool >(val2);
28588 {
28589 PyThreadState* __tstate = wxPyBeginAllowThreads();
28590 (arg1)->SetPaletteRealized(arg2);
28591 wxPyEndAllowThreads(__tstate);
28592 if (PyErr_Occurred()) SWIG_fail;
28593 }
28594 resultobj = SWIG_Py_Void();
28595 return resultobj;
28596 fail:
28597 return NULL;
28598 }
28599
28600
28601 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28602 PyObject *resultobj = 0;
28603 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28604 bool result;
28605 void *argp1 = 0 ;
28606 int res1 = 0 ;
28607 PyObject *swig_obj[1] ;
28608
28609 if (!args) SWIG_fail;
28610 swig_obj[0] = args;
28611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28612 if (!SWIG_IsOK(res1)) {
28613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28614 }
28615 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28616 {
28617 PyThreadState* __tstate = wxPyBeginAllowThreads();
28618 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28619 wxPyEndAllowThreads(__tstate);
28620 if (PyErr_Occurred()) SWIG_fail;
28621 }
28622 {
28623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28624 }
28625 return resultobj;
28626 fail:
28627 return NULL;
28628 }
28629
28630
28631 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28632 PyObject *obj;
28633 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28634 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28635 return SWIG_Py_Void();
28636 }
28637
28638 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28639 return SWIG_Python_InitShadowInstance(args);
28640 }
28641
28642 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28643 PyObject *resultobj = 0;
28644 wxNavigationKeyEvent *result = 0 ;
28645
28646 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28647 {
28648 PyThreadState* __tstate = wxPyBeginAllowThreads();
28649 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28650 wxPyEndAllowThreads(__tstate);
28651 if (PyErr_Occurred()) SWIG_fail;
28652 }
28653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28654 return resultobj;
28655 fail:
28656 return NULL;
28657 }
28658
28659
28660 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28661 PyObject *resultobj = 0;
28662 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28663 bool result;
28664 void *argp1 = 0 ;
28665 int res1 = 0 ;
28666 PyObject *swig_obj[1] ;
28667
28668 if (!args) SWIG_fail;
28669 swig_obj[0] = args;
28670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28671 if (!SWIG_IsOK(res1)) {
28672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28673 }
28674 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28675 {
28676 PyThreadState* __tstate = wxPyBeginAllowThreads();
28677 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28678 wxPyEndAllowThreads(__tstate);
28679 if (PyErr_Occurred()) SWIG_fail;
28680 }
28681 {
28682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28683 }
28684 return resultobj;
28685 fail:
28686 return NULL;
28687 }
28688
28689
28690 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28691 PyObject *resultobj = 0;
28692 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28693 bool arg2 ;
28694 void *argp1 = 0 ;
28695 int res1 = 0 ;
28696 bool val2 ;
28697 int ecode2 = 0 ;
28698 PyObject * obj0 = 0 ;
28699 PyObject * obj1 = 0 ;
28700 char * kwnames[] = {
28701 (char *) "self",(char *) "forward", NULL
28702 };
28703
28704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28706 if (!SWIG_IsOK(res1)) {
28707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28708 }
28709 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28710 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28711 if (!SWIG_IsOK(ecode2)) {
28712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28713 }
28714 arg2 = static_cast< bool >(val2);
28715 {
28716 PyThreadState* __tstate = wxPyBeginAllowThreads();
28717 (arg1)->SetDirection(arg2);
28718 wxPyEndAllowThreads(__tstate);
28719 if (PyErr_Occurred()) SWIG_fail;
28720 }
28721 resultobj = SWIG_Py_Void();
28722 return resultobj;
28723 fail:
28724 return NULL;
28725 }
28726
28727
28728 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28729 PyObject *resultobj = 0;
28730 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28731 bool result;
28732 void *argp1 = 0 ;
28733 int res1 = 0 ;
28734 PyObject *swig_obj[1] ;
28735
28736 if (!args) SWIG_fail;
28737 swig_obj[0] = args;
28738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28739 if (!SWIG_IsOK(res1)) {
28740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28741 }
28742 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28743 {
28744 PyThreadState* __tstate = wxPyBeginAllowThreads();
28745 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28746 wxPyEndAllowThreads(__tstate);
28747 if (PyErr_Occurred()) SWIG_fail;
28748 }
28749 {
28750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28751 }
28752 return resultobj;
28753 fail:
28754 return NULL;
28755 }
28756
28757
28758 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28759 PyObject *resultobj = 0;
28760 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28761 bool arg2 ;
28762 void *argp1 = 0 ;
28763 int res1 = 0 ;
28764 bool val2 ;
28765 int ecode2 = 0 ;
28766 PyObject * obj0 = 0 ;
28767 PyObject * obj1 = 0 ;
28768 char * kwnames[] = {
28769 (char *) "self",(char *) "ischange", NULL
28770 };
28771
28772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28774 if (!SWIG_IsOK(res1)) {
28775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28776 }
28777 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28778 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28779 if (!SWIG_IsOK(ecode2)) {
28780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28781 }
28782 arg2 = static_cast< bool >(val2);
28783 {
28784 PyThreadState* __tstate = wxPyBeginAllowThreads();
28785 (arg1)->SetWindowChange(arg2);
28786 wxPyEndAllowThreads(__tstate);
28787 if (PyErr_Occurred()) SWIG_fail;
28788 }
28789 resultobj = SWIG_Py_Void();
28790 return resultobj;
28791 fail:
28792 return NULL;
28793 }
28794
28795
28796 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28797 PyObject *resultobj = 0;
28798 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28799 bool result;
28800 void *argp1 = 0 ;
28801 int res1 = 0 ;
28802 PyObject *swig_obj[1] ;
28803
28804 if (!args) SWIG_fail;
28805 swig_obj[0] = args;
28806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28807 if (!SWIG_IsOK(res1)) {
28808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28809 }
28810 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28811 {
28812 PyThreadState* __tstate = wxPyBeginAllowThreads();
28813 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 {
28818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28819 }
28820 return resultobj;
28821 fail:
28822 return NULL;
28823 }
28824
28825
28826 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28827 PyObject *resultobj = 0;
28828 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28829 bool arg2 ;
28830 void *argp1 = 0 ;
28831 int res1 = 0 ;
28832 bool val2 ;
28833 int ecode2 = 0 ;
28834 PyObject * obj0 = 0 ;
28835 PyObject * obj1 = 0 ;
28836 char * kwnames[] = {
28837 (char *) "self",(char *) "bIs", NULL
28838 };
28839
28840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28842 if (!SWIG_IsOK(res1)) {
28843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28844 }
28845 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28846 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28847 if (!SWIG_IsOK(ecode2)) {
28848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28849 }
28850 arg2 = static_cast< bool >(val2);
28851 {
28852 PyThreadState* __tstate = wxPyBeginAllowThreads();
28853 (arg1)->SetFromTab(arg2);
28854 wxPyEndAllowThreads(__tstate);
28855 if (PyErr_Occurred()) SWIG_fail;
28856 }
28857 resultobj = SWIG_Py_Void();
28858 return resultobj;
28859 fail:
28860 return NULL;
28861 }
28862
28863
28864 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28865 PyObject *resultobj = 0;
28866 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28867 long arg2 ;
28868 void *argp1 = 0 ;
28869 int res1 = 0 ;
28870 long val2 ;
28871 int ecode2 = 0 ;
28872 PyObject * obj0 = 0 ;
28873 PyObject * obj1 = 0 ;
28874 char * kwnames[] = {
28875 (char *) "self",(char *) "flags", NULL
28876 };
28877
28878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28880 if (!SWIG_IsOK(res1)) {
28881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28882 }
28883 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28884 ecode2 = SWIG_AsVal_long(obj1, &val2);
28885 if (!SWIG_IsOK(ecode2)) {
28886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28887 }
28888 arg2 = static_cast< long >(val2);
28889 {
28890 PyThreadState* __tstate = wxPyBeginAllowThreads();
28891 (arg1)->SetFlags(arg2);
28892 wxPyEndAllowThreads(__tstate);
28893 if (PyErr_Occurred()) SWIG_fail;
28894 }
28895 resultobj = SWIG_Py_Void();
28896 return resultobj;
28897 fail:
28898 return NULL;
28899 }
28900
28901
28902 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28903 PyObject *resultobj = 0;
28904 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28905 wxWindow *result = 0 ;
28906 void *argp1 = 0 ;
28907 int res1 = 0 ;
28908 PyObject *swig_obj[1] ;
28909
28910 if (!args) SWIG_fail;
28911 swig_obj[0] = args;
28912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28913 if (!SWIG_IsOK(res1)) {
28914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28915 }
28916 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28917 {
28918 PyThreadState* __tstate = wxPyBeginAllowThreads();
28919 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
28920 wxPyEndAllowThreads(__tstate);
28921 if (PyErr_Occurred()) SWIG_fail;
28922 }
28923 {
28924 resultobj = wxPyMake_wxObject(result, (bool)0);
28925 }
28926 return resultobj;
28927 fail:
28928 return NULL;
28929 }
28930
28931
28932 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28933 PyObject *resultobj = 0;
28934 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28935 wxWindow *arg2 = (wxWindow *) 0 ;
28936 void *argp1 = 0 ;
28937 int res1 = 0 ;
28938 void *argp2 = 0 ;
28939 int res2 = 0 ;
28940 PyObject * obj0 = 0 ;
28941 PyObject * obj1 = 0 ;
28942 char * kwnames[] = {
28943 (char *) "self",(char *) "win", NULL
28944 };
28945
28946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
28947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28948 if (!SWIG_IsOK(res1)) {
28949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28950 }
28951 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28952 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28953 if (!SWIG_IsOK(res2)) {
28954 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
28955 }
28956 arg2 = reinterpret_cast< wxWindow * >(argp2);
28957 {
28958 PyThreadState* __tstate = wxPyBeginAllowThreads();
28959 (arg1)->SetCurrentFocus(arg2);
28960 wxPyEndAllowThreads(__tstate);
28961 if (PyErr_Occurred()) SWIG_fail;
28962 }
28963 resultobj = SWIG_Py_Void();
28964 return resultobj;
28965 fail:
28966 return NULL;
28967 }
28968
28969
28970 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28971 PyObject *obj;
28972 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28973 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
28974 return SWIG_Py_Void();
28975 }
28976
28977 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28978 return SWIG_Python_InitShadowInstance(args);
28979 }
28980
28981 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28982 PyObject *resultobj = 0;
28983 wxWindow *arg1 = (wxWindow *) NULL ;
28984 wxWindowCreateEvent *result = 0 ;
28985 void *argp1 = 0 ;
28986 int res1 = 0 ;
28987 PyObject * obj0 = 0 ;
28988 char * kwnames[] = {
28989 (char *) "win", NULL
28990 };
28991
28992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
28993 if (obj0) {
28994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28995 if (!SWIG_IsOK(res1)) {
28996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
28997 }
28998 arg1 = reinterpret_cast< wxWindow * >(argp1);
28999 }
29000 {
29001 PyThreadState* __tstate = wxPyBeginAllowThreads();
29002 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29003 wxPyEndAllowThreads(__tstate);
29004 if (PyErr_Occurred()) SWIG_fail;
29005 }
29006 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29007 return resultobj;
29008 fail:
29009 return NULL;
29010 }
29011
29012
29013 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29014 PyObject *resultobj = 0;
29015 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29016 wxWindow *result = 0 ;
29017 void *argp1 = 0 ;
29018 int res1 = 0 ;
29019 PyObject *swig_obj[1] ;
29020
29021 if (!args) SWIG_fail;
29022 swig_obj[0] = args;
29023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29024 if (!SWIG_IsOK(res1)) {
29025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29026 }
29027 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29028 {
29029 PyThreadState* __tstate = wxPyBeginAllowThreads();
29030 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29031 wxPyEndAllowThreads(__tstate);
29032 if (PyErr_Occurred()) SWIG_fail;
29033 }
29034 {
29035 resultobj = wxPyMake_wxObject(result, (bool)0);
29036 }
29037 return resultobj;
29038 fail:
29039 return NULL;
29040 }
29041
29042
29043 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29044 PyObject *obj;
29045 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29046 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29047 return SWIG_Py_Void();
29048 }
29049
29050 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29051 return SWIG_Python_InitShadowInstance(args);
29052 }
29053
29054 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29055 PyObject *resultobj = 0;
29056 wxWindow *arg1 = (wxWindow *) NULL ;
29057 wxWindowDestroyEvent *result = 0 ;
29058 void *argp1 = 0 ;
29059 int res1 = 0 ;
29060 PyObject * obj0 = 0 ;
29061 char * kwnames[] = {
29062 (char *) "win", NULL
29063 };
29064
29065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29066 if (obj0) {
29067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29068 if (!SWIG_IsOK(res1)) {
29069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29070 }
29071 arg1 = reinterpret_cast< wxWindow * >(argp1);
29072 }
29073 {
29074 PyThreadState* __tstate = wxPyBeginAllowThreads();
29075 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29076 wxPyEndAllowThreads(__tstate);
29077 if (PyErr_Occurred()) SWIG_fail;
29078 }
29079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29080 return resultobj;
29081 fail:
29082 return NULL;
29083 }
29084
29085
29086 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29087 PyObject *resultobj = 0;
29088 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29089 wxWindow *result = 0 ;
29090 void *argp1 = 0 ;
29091 int res1 = 0 ;
29092 PyObject *swig_obj[1] ;
29093
29094 if (!args) SWIG_fail;
29095 swig_obj[0] = args;
29096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29097 if (!SWIG_IsOK(res1)) {
29098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29099 }
29100 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29101 {
29102 PyThreadState* __tstate = wxPyBeginAllowThreads();
29103 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29104 wxPyEndAllowThreads(__tstate);
29105 if (PyErr_Occurred()) SWIG_fail;
29106 }
29107 {
29108 resultobj = wxPyMake_wxObject(result, (bool)0);
29109 }
29110 return resultobj;
29111 fail:
29112 return NULL;
29113 }
29114
29115
29116 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29117 PyObject *obj;
29118 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29119 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29120 return SWIG_Py_Void();
29121 }
29122
29123 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29124 return SWIG_Python_InitShadowInstance(args);
29125 }
29126
29127 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29128 PyObject *resultobj = 0;
29129 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29130 int arg2 = (int) 0 ;
29131 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29132 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29133 wxContextMenuEvent *result = 0 ;
29134 int val1 ;
29135 int ecode1 = 0 ;
29136 int val2 ;
29137 int ecode2 = 0 ;
29138 wxPoint temp3 ;
29139 PyObject * obj0 = 0 ;
29140 PyObject * obj1 = 0 ;
29141 PyObject * obj2 = 0 ;
29142 char * kwnames[] = {
29143 (char *) "type",(char *) "winid",(char *) "pt", NULL
29144 };
29145
29146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29147 if (obj0) {
29148 ecode1 = SWIG_AsVal_int(obj0, &val1);
29149 if (!SWIG_IsOK(ecode1)) {
29150 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29151 }
29152 arg1 = static_cast< wxEventType >(val1);
29153 }
29154 if (obj1) {
29155 ecode2 = SWIG_AsVal_int(obj1, &val2);
29156 if (!SWIG_IsOK(ecode2)) {
29157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29158 }
29159 arg2 = static_cast< int >(val2);
29160 }
29161 if (obj2) {
29162 {
29163 arg3 = &temp3;
29164 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29165 }
29166 }
29167 {
29168 PyThreadState* __tstate = wxPyBeginAllowThreads();
29169 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29170 wxPyEndAllowThreads(__tstate);
29171 if (PyErr_Occurred()) SWIG_fail;
29172 }
29173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29174 return resultobj;
29175 fail:
29176 return NULL;
29177 }
29178
29179
29180 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29181 PyObject *resultobj = 0;
29182 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29183 wxPoint *result = 0 ;
29184 void *argp1 = 0 ;
29185 int res1 = 0 ;
29186 PyObject *swig_obj[1] ;
29187
29188 if (!args) SWIG_fail;
29189 swig_obj[0] = args;
29190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29191 if (!SWIG_IsOK(res1)) {
29192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29193 }
29194 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29195 {
29196 PyThreadState* __tstate = wxPyBeginAllowThreads();
29197 {
29198 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29199 result = (wxPoint *) &_result_ref;
29200 }
29201 wxPyEndAllowThreads(__tstate);
29202 if (PyErr_Occurred()) SWIG_fail;
29203 }
29204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29205 return resultobj;
29206 fail:
29207 return NULL;
29208 }
29209
29210
29211 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29212 PyObject *resultobj = 0;
29213 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29214 wxPoint *arg2 = 0 ;
29215 void *argp1 = 0 ;
29216 int res1 = 0 ;
29217 wxPoint temp2 ;
29218 PyObject * obj0 = 0 ;
29219 PyObject * obj1 = 0 ;
29220 char * kwnames[] = {
29221 (char *) "self",(char *) "pos", NULL
29222 };
29223
29224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29226 if (!SWIG_IsOK(res1)) {
29227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29228 }
29229 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29230 {
29231 arg2 = &temp2;
29232 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29233 }
29234 {
29235 PyThreadState* __tstate = wxPyBeginAllowThreads();
29236 (arg1)->SetPosition((wxPoint const &)*arg2);
29237 wxPyEndAllowThreads(__tstate);
29238 if (PyErr_Occurred()) SWIG_fail;
29239 }
29240 resultobj = SWIG_Py_Void();
29241 return resultobj;
29242 fail:
29243 return NULL;
29244 }
29245
29246
29247 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29248 PyObject *obj;
29249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29250 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29251 return SWIG_Py_Void();
29252 }
29253
29254 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29255 return SWIG_Python_InitShadowInstance(args);
29256 }
29257
29258 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29259 PyObject *resultobj = 0;
29260 wxIdleEvent *result = 0 ;
29261
29262 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29263 {
29264 PyThreadState* __tstate = wxPyBeginAllowThreads();
29265 result = (wxIdleEvent *)new wxIdleEvent();
29266 wxPyEndAllowThreads(__tstate);
29267 if (PyErr_Occurred()) SWIG_fail;
29268 }
29269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29270 return resultobj;
29271 fail:
29272 return NULL;
29273 }
29274
29275
29276 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29277 PyObject *resultobj = 0;
29278 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29279 bool arg2 = (bool) true ;
29280 void *argp1 = 0 ;
29281 int res1 = 0 ;
29282 bool val2 ;
29283 int ecode2 = 0 ;
29284 PyObject * obj0 = 0 ;
29285 PyObject * obj1 = 0 ;
29286 char * kwnames[] = {
29287 (char *) "self",(char *) "needMore", NULL
29288 };
29289
29290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29292 if (!SWIG_IsOK(res1)) {
29293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29294 }
29295 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29296 if (obj1) {
29297 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29298 if (!SWIG_IsOK(ecode2)) {
29299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29300 }
29301 arg2 = static_cast< bool >(val2);
29302 }
29303 {
29304 PyThreadState* __tstate = wxPyBeginAllowThreads();
29305 (arg1)->RequestMore(arg2);
29306 wxPyEndAllowThreads(__tstate);
29307 if (PyErr_Occurred()) SWIG_fail;
29308 }
29309 resultobj = SWIG_Py_Void();
29310 return resultobj;
29311 fail:
29312 return NULL;
29313 }
29314
29315
29316 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29317 PyObject *resultobj = 0;
29318 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29319 bool result;
29320 void *argp1 = 0 ;
29321 int res1 = 0 ;
29322 PyObject *swig_obj[1] ;
29323
29324 if (!args) SWIG_fail;
29325 swig_obj[0] = args;
29326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29327 if (!SWIG_IsOK(res1)) {
29328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29329 }
29330 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29331 {
29332 PyThreadState* __tstate = wxPyBeginAllowThreads();
29333 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29334 wxPyEndAllowThreads(__tstate);
29335 if (PyErr_Occurred()) SWIG_fail;
29336 }
29337 {
29338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29339 }
29340 return resultobj;
29341 fail:
29342 return NULL;
29343 }
29344
29345
29346 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29347 PyObject *resultobj = 0;
29348 wxIdleMode arg1 ;
29349 int val1 ;
29350 int ecode1 = 0 ;
29351 PyObject * obj0 = 0 ;
29352 char * kwnames[] = {
29353 (char *) "mode", NULL
29354 };
29355
29356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29357 ecode1 = SWIG_AsVal_int(obj0, &val1);
29358 if (!SWIG_IsOK(ecode1)) {
29359 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29360 }
29361 arg1 = static_cast< wxIdleMode >(val1);
29362 {
29363 PyThreadState* __tstate = wxPyBeginAllowThreads();
29364 wxIdleEvent::SetMode(arg1);
29365 wxPyEndAllowThreads(__tstate);
29366 if (PyErr_Occurred()) SWIG_fail;
29367 }
29368 resultobj = SWIG_Py_Void();
29369 return resultobj;
29370 fail:
29371 return NULL;
29372 }
29373
29374
29375 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29376 PyObject *resultobj = 0;
29377 wxIdleMode result;
29378
29379 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29380 {
29381 PyThreadState* __tstate = wxPyBeginAllowThreads();
29382 result = (wxIdleMode)wxIdleEvent::GetMode();
29383 wxPyEndAllowThreads(__tstate);
29384 if (PyErr_Occurred()) SWIG_fail;
29385 }
29386 resultobj = SWIG_From_int(static_cast< int >(result));
29387 return resultobj;
29388 fail:
29389 return NULL;
29390 }
29391
29392
29393 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29394 PyObject *resultobj = 0;
29395 wxWindow *arg1 = (wxWindow *) 0 ;
29396 bool result;
29397 void *argp1 = 0 ;
29398 int res1 = 0 ;
29399 PyObject * obj0 = 0 ;
29400 char * kwnames[] = {
29401 (char *) "win", NULL
29402 };
29403
29404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29406 if (!SWIG_IsOK(res1)) {
29407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29408 }
29409 arg1 = reinterpret_cast< wxWindow * >(argp1);
29410 {
29411 PyThreadState* __tstate = wxPyBeginAllowThreads();
29412 result = (bool)wxIdleEvent::CanSend(arg1);
29413 wxPyEndAllowThreads(__tstate);
29414 if (PyErr_Occurred()) SWIG_fail;
29415 }
29416 {
29417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29418 }
29419 return resultobj;
29420 fail:
29421 return NULL;
29422 }
29423
29424
29425 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29426 PyObject *obj;
29427 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29428 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29429 return SWIG_Py_Void();
29430 }
29431
29432 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29433 return SWIG_Python_InitShadowInstance(args);
29434 }
29435
29436 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29437 PyObject *resultobj = 0;
29438 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29439 int arg2 = (int) 0 ;
29440 wxClipboardTextEvent *result = 0 ;
29441 int val1 ;
29442 int ecode1 = 0 ;
29443 int val2 ;
29444 int ecode2 = 0 ;
29445 PyObject * obj0 = 0 ;
29446 PyObject * obj1 = 0 ;
29447 char * kwnames[] = {
29448 (char *) "type",(char *) "winid", NULL
29449 };
29450
29451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29452 if (obj0) {
29453 ecode1 = SWIG_AsVal_int(obj0, &val1);
29454 if (!SWIG_IsOK(ecode1)) {
29455 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29456 }
29457 arg1 = static_cast< wxEventType >(val1);
29458 }
29459 if (obj1) {
29460 ecode2 = SWIG_AsVal_int(obj1, &val2);
29461 if (!SWIG_IsOK(ecode2)) {
29462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29463 }
29464 arg2 = static_cast< int >(val2);
29465 }
29466 {
29467 PyThreadState* __tstate = wxPyBeginAllowThreads();
29468 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29469 wxPyEndAllowThreads(__tstate);
29470 if (PyErr_Occurred()) SWIG_fail;
29471 }
29472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29473 return resultobj;
29474 fail:
29475 return NULL;
29476 }
29477
29478
29479 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29480 PyObject *obj;
29481 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29482 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29483 return SWIG_Py_Void();
29484 }
29485
29486 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29487 return SWIG_Python_InitShadowInstance(args);
29488 }
29489
29490 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29491 PyObject *resultobj = 0;
29492 int arg1 = (int) 0 ;
29493 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29494 wxPyEvent *result = 0 ;
29495 int val1 ;
29496 int ecode1 = 0 ;
29497 int val2 ;
29498 int ecode2 = 0 ;
29499 PyObject * obj0 = 0 ;
29500 PyObject * obj1 = 0 ;
29501 char * kwnames[] = {
29502 (char *) "winid",(char *) "eventType", NULL
29503 };
29504
29505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29506 if (obj0) {
29507 ecode1 = SWIG_AsVal_int(obj0, &val1);
29508 if (!SWIG_IsOK(ecode1)) {
29509 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29510 }
29511 arg1 = static_cast< int >(val1);
29512 }
29513 if (obj1) {
29514 ecode2 = SWIG_AsVal_int(obj1, &val2);
29515 if (!SWIG_IsOK(ecode2)) {
29516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29517 }
29518 arg2 = static_cast< wxEventType >(val2);
29519 }
29520 {
29521 PyThreadState* __tstate = wxPyBeginAllowThreads();
29522 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29523 wxPyEndAllowThreads(__tstate);
29524 if (PyErr_Occurred()) SWIG_fail;
29525 }
29526 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29527 return resultobj;
29528 fail:
29529 return NULL;
29530 }
29531
29532
29533 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29534 PyObject *resultobj = 0;
29535 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29536 void *argp1 = 0 ;
29537 int res1 = 0 ;
29538 PyObject *swig_obj[1] ;
29539
29540 if (!args) SWIG_fail;
29541 swig_obj[0] = args;
29542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29543 if (!SWIG_IsOK(res1)) {
29544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29545 }
29546 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29547 {
29548 PyThreadState* __tstate = wxPyBeginAllowThreads();
29549 delete arg1;
29550
29551 wxPyEndAllowThreads(__tstate);
29552 if (PyErr_Occurred()) SWIG_fail;
29553 }
29554 resultobj = SWIG_Py_Void();
29555 return resultobj;
29556 fail:
29557 return NULL;
29558 }
29559
29560
29561 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29562 PyObject *resultobj = 0;
29563 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29564 PyObject *arg2 = (PyObject *) 0 ;
29565 void *argp1 = 0 ;
29566 int res1 = 0 ;
29567 PyObject * obj0 = 0 ;
29568 PyObject * obj1 = 0 ;
29569 char * kwnames[] = {
29570 (char *) "self",(char *) "self", NULL
29571 };
29572
29573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29575 if (!SWIG_IsOK(res1)) {
29576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29577 }
29578 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29579 arg2 = obj1;
29580 {
29581 PyThreadState* __tstate = wxPyBeginAllowThreads();
29582 (arg1)->SetSelf(arg2);
29583 wxPyEndAllowThreads(__tstate);
29584 if (PyErr_Occurred()) SWIG_fail;
29585 }
29586 resultobj = SWIG_Py_Void();
29587 return resultobj;
29588 fail:
29589 return NULL;
29590 }
29591
29592
29593 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29594 PyObject *resultobj = 0;
29595 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29596 PyObject *result = 0 ;
29597 void *argp1 = 0 ;
29598 int res1 = 0 ;
29599 PyObject *swig_obj[1] ;
29600
29601 if (!args) SWIG_fail;
29602 swig_obj[0] = args;
29603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29604 if (!SWIG_IsOK(res1)) {
29605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29606 }
29607 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29608 {
29609 PyThreadState* __tstate = wxPyBeginAllowThreads();
29610 result = (PyObject *)(arg1)->GetSelf();
29611 wxPyEndAllowThreads(__tstate);
29612 if (PyErr_Occurred()) SWIG_fail;
29613 }
29614 resultobj = result;
29615 return resultobj;
29616 fail:
29617 return NULL;
29618 }
29619
29620
29621 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29622 PyObject *obj;
29623 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29624 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29625 return SWIG_Py_Void();
29626 }
29627
29628 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29629 return SWIG_Python_InitShadowInstance(args);
29630 }
29631
29632 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29633 PyObject *resultobj = 0;
29634 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29635 int arg2 = (int) 0 ;
29636 wxPyCommandEvent *result = 0 ;
29637 int val1 ;
29638 int ecode1 = 0 ;
29639 int val2 ;
29640 int ecode2 = 0 ;
29641 PyObject * obj0 = 0 ;
29642 PyObject * obj1 = 0 ;
29643 char * kwnames[] = {
29644 (char *) "eventType",(char *) "id", NULL
29645 };
29646
29647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29648 if (obj0) {
29649 ecode1 = SWIG_AsVal_int(obj0, &val1);
29650 if (!SWIG_IsOK(ecode1)) {
29651 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29652 }
29653 arg1 = static_cast< wxEventType >(val1);
29654 }
29655 if (obj1) {
29656 ecode2 = SWIG_AsVal_int(obj1, &val2);
29657 if (!SWIG_IsOK(ecode2)) {
29658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29659 }
29660 arg2 = static_cast< int >(val2);
29661 }
29662 {
29663 PyThreadState* __tstate = wxPyBeginAllowThreads();
29664 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29665 wxPyEndAllowThreads(__tstate);
29666 if (PyErr_Occurred()) SWIG_fail;
29667 }
29668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29669 return resultobj;
29670 fail:
29671 return NULL;
29672 }
29673
29674
29675 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29676 PyObject *resultobj = 0;
29677 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29678 void *argp1 = 0 ;
29679 int res1 = 0 ;
29680 PyObject *swig_obj[1] ;
29681
29682 if (!args) SWIG_fail;
29683 swig_obj[0] = args;
29684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29685 if (!SWIG_IsOK(res1)) {
29686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29687 }
29688 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29689 {
29690 PyThreadState* __tstate = wxPyBeginAllowThreads();
29691 delete arg1;
29692
29693 wxPyEndAllowThreads(__tstate);
29694 if (PyErr_Occurred()) SWIG_fail;
29695 }
29696 resultobj = SWIG_Py_Void();
29697 return resultobj;
29698 fail:
29699 return NULL;
29700 }
29701
29702
29703 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29704 PyObject *resultobj = 0;
29705 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29706 PyObject *arg2 = (PyObject *) 0 ;
29707 void *argp1 = 0 ;
29708 int res1 = 0 ;
29709 PyObject * obj0 = 0 ;
29710 PyObject * obj1 = 0 ;
29711 char * kwnames[] = {
29712 (char *) "self",(char *) "self", NULL
29713 };
29714
29715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29717 if (!SWIG_IsOK(res1)) {
29718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29719 }
29720 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29721 arg2 = obj1;
29722 {
29723 PyThreadState* __tstate = wxPyBeginAllowThreads();
29724 (arg1)->SetSelf(arg2);
29725 wxPyEndAllowThreads(__tstate);
29726 if (PyErr_Occurred()) SWIG_fail;
29727 }
29728 resultobj = SWIG_Py_Void();
29729 return resultobj;
29730 fail:
29731 return NULL;
29732 }
29733
29734
29735 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29736 PyObject *resultobj = 0;
29737 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29738 PyObject *result = 0 ;
29739 void *argp1 = 0 ;
29740 int res1 = 0 ;
29741 PyObject *swig_obj[1] ;
29742
29743 if (!args) SWIG_fail;
29744 swig_obj[0] = args;
29745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29746 if (!SWIG_IsOK(res1)) {
29747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29748 }
29749 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29750 {
29751 PyThreadState* __tstate = wxPyBeginAllowThreads();
29752 result = (PyObject *)(arg1)->GetSelf();
29753 wxPyEndAllowThreads(__tstate);
29754 if (PyErr_Occurred()) SWIG_fail;
29755 }
29756 resultobj = result;
29757 return resultobj;
29758 fail:
29759 return NULL;
29760 }
29761
29762
29763 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29764 PyObject *obj;
29765 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29766 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29767 return SWIG_Py_Void();
29768 }
29769
29770 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29771 return SWIG_Python_InitShadowInstance(args);
29772 }
29773
29774 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29775 PyObject *resultobj = 0;
29776 wxWindow *arg1 = (wxWindow *) 0 ;
29777 wxDateTime *arg2 = 0 ;
29778 wxEventType arg3 ;
29779 wxDateEvent *result = 0 ;
29780 void *argp1 = 0 ;
29781 int res1 = 0 ;
29782 void *argp2 = 0 ;
29783 int res2 = 0 ;
29784 int val3 ;
29785 int ecode3 = 0 ;
29786 PyObject * obj0 = 0 ;
29787 PyObject * obj1 = 0 ;
29788 PyObject * obj2 = 0 ;
29789 char * kwnames[] = {
29790 (char *) "win",(char *) "dt",(char *) "type", NULL
29791 };
29792
29793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29795 if (!SWIG_IsOK(res1)) {
29796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29797 }
29798 arg1 = reinterpret_cast< wxWindow * >(argp1);
29799 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29800 if (!SWIG_IsOK(res2)) {
29801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29802 }
29803 if (!argp2) {
29804 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29805 }
29806 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29807 ecode3 = SWIG_AsVal_int(obj2, &val3);
29808 if (!SWIG_IsOK(ecode3)) {
29809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29810 }
29811 arg3 = static_cast< wxEventType >(val3);
29812 {
29813 PyThreadState* __tstate = wxPyBeginAllowThreads();
29814 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29815 wxPyEndAllowThreads(__tstate);
29816 if (PyErr_Occurred()) SWIG_fail;
29817 }
29818 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29819 return resultobj;
29820 fail:
29821 return NULL;
29822 }
29823
29824
29825 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29826 PyObject *resultobj = 0;
29827 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29828 wxDateTime *result = 0 ;
29829 void *argp1 = 0 ;
29830 int res1 = 0 ;
29831 PyObject *swig_obj[1] ;
29832
29833 if (!args) SWIG_fail;
29834 swig_obj[0] = args;
29835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29836 if (!SWIG_IsOK(res1)) {
29837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29838 }
29839 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29840 {
29841 PyThreadState* __tstate = wxPyBeginAllowThreads();
29842 {
29843 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29844 result = (wxDateTime *) &_result_ref;
29845 }
29846 wxPyEndAllowThreads(__tstate);
29847 if (PyErr_Occurred()) SWIG_fail;
29848 }
29849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29850 return resultobj;
29851 fail:
29852 return NULL;
29853 }
29854
29855
29856 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29857 PyObject *resultobj = 0;
29858 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29859 wxDateTime *arg2 = 0 ;
29860 void *argp1 = 0 ;
29861 int res1 = 0 ;
29862 void *argp2 = 0 ;
29863 int res2 = 0 ;
29864 PyObject * obj0 = 0 ;
29865 PyObject * obj1 = 0 ;
29866 char * kwnames[] = {
29867 (char *) "self",(char *) "date", NULL
29868 };
29869
29870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29872 if (!SWIG_IsOK(res1)) {
29873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29874 }
29875 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29876 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29877 if (!SWIG_IsOK(res2)) {
29878 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29879 }
29880 if (!argp2) {
29881 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29882 }
29883 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29884 {
29885 PyThreadState* __tstate = wxPyBeginAllowThreads();
29886 (arg1)->SetDate((wxDateTime const &)*arg2);
29887 wxPyEndAllowThreads(__tstate);
29888 if (PyErr_Occurred()) SWIG_fail;
29889 }
29890 resultobj = SWIG_Py_Void();
29891 return resultobj;
29892 fail:
29893 return NULL;
29894 }
29895
29896
29897 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29898 PyObject *obj;
29899 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29900 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
29901 return SWIG_Py_Void();
29902 }
29903
29904 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29905 return SWIG_Python_InitShadowInstance(args);
29906 }
29907
29908 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29909 PyObject *resultobj = 0;
29910 wxPyApp *result = 0 ;
29911
29912 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
29913 {
29914 PyThreadState* __tstate = wxPyBeginAllowThreads();
29915 result = (wxPyApp *)new_wxPyApp();
29916 wxPyEndAllowThreads(__tstate);
29917 if (PyErr_Occurred()) SWIG_fail;
29918 }
29919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
29920 return resultobj;
29921 fail:
29922 return NULL;
29923 }
29924
29925
29926 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29927 PyObject *resultobj = 0;
29928 wxPyApp *arg1 = (wxPyApp *) 0 ;
29929 void *argp1 = 0 ;
29930 int res1 = 0 ;
29931 PyObject *swig_obj[1] ;
29932
29933 if (!args) SWIG_fail;
29934 swig_obj[0] = args;
29935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
29936 if (!SWIG_IsOK(res1)) {
29937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
29938 }
29939 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29940 {
29941 PyThreadState* __tstate = wxPyBeginAllowThreads();
29942 delete arg1;
29943
29944 wxPyEndAllowThreads(__tstate);
29945 if (PyErr_Occurred()) SWIG_fail;
29946 }
29947 resultobj = SWIG_Py_Void();
29948 return resultobj;
29949 fail:
29950 return NULL;
29951 }
29952
29953
29954 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29955 PyObject *resultobj = 0;
29956 wxPyApp *arg1 = (wxPyApp *) 0 ;
29957 PyObject *arg2 = (PyObject *) 0 ;
29958 PyObject *arg3 = (PyObject *) 0 ;
29959 bool arg4 = (bool) false ;
29960 void *argp1 = 0 ;
29961 int res1 = 0 ;
29962 bool val4 ;
29963 int ecode4 = 0 ;
29964 PyObject * obj0 = 0 ;
29965 PyObject * obj1 = 0 ;
29966 PyObject * obj2 = 0 ;
29967 PyObject * obj3 = 0 ;
29968 char * kwnames[] = {
29969 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
29970 };
29971
29972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29974 if (!SWIG_IsOK(res1)) {
29975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
29976 }
29977 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29978 arg2 = obj1;
29979 arg3 = obj2;
29980 if (obj3) {
29981 ecode4 = SWIG_AsVal_bool(obj3, &val4);
29982 if (!SWIG_IsOK(ecode4)) {
29983 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
29984 }
29985 arg4 = static_cast< bool >(val4);
29986 }
29987 {
29988 PyThreadState* __tstate = wxPyBeginAllowThreads();
29989 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
29990 wxPyEndAllowThreads(__tstate);
29991 if (PyErr_Occurred()) SWIG_fail;
29992 }
29993 resultobj = SWIG_Py_Void();
29994 return resultobj;
29995 fail:
29996 return NULL;
29997 }
29998
29999
30000 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30001 PyObject *resultobj = 0;
30002 wxPyApp *arg1 = (wxPyApp *) 0 ;
30003 wxString result;
30004 void *argp1 = 0 ;
30005 int res1 = 0 ;
30006 PyObject *swig_obj[1] ;
30007
30008 if (!args) SWIG_fail;
30009 swig_obj[0] = args;
30010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30011 if (!SWIG_IsOK(res1)) {
30012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30013 }
30014 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30015 {
30016 PyThreadState* __tstate = wxPyBeginAllowThreads();
30017 result = ((wxPyApp const *)arg1)->GetAppName();
30018 wxPyEndAllowThreads(__tstate);
30019 if (PyErr_Occurred()) SWIG_fail;
30020 }
30021 {
30022 #if wxUSE_UNICODE
30023 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30024 #else
30025 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30026 #endif
30027 }
30028 return resultobj;
30029 fail:
30030 return NULL;
30031 }
30032
30033
30034 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30035 PyObject *resultobj = 0;
30036 wxPyApp *arg1 = (wxPyApp *) 0 ;
30037 wxString *arg2 = 0 ;
30038 void *argp1 = 0 ;
30039 int res1 = 0 ;
30040 bool temp2 = false ;
30041 PyObject * obj0 = 0 ;
30042 PyObject * obj1 = 0 ;
30043 char * kwnames[] = {
30044 (char *) "self",(char *) "name", NULL
30045 };
30046
30047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30049 if (!SWIG_IsOK(res1)) {
30050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30051 }
30052 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30053 {
30054 arg2 = wxString_in_helper(obj1);
30055 if (arg2 == NULL) SWIG_fail;
30056 temp2 = true;
30057 }
30058 {
30059 PyThreadState* __tstate = wxPyBeginAllowThreads();
30060 (arg1)->SetAppName((wxString const &)*arg2);
30061 wxPyEndAllowThreads(__tstate);
30062 if (PyErr_Occurred()) SWIG_fail;
30063 }
30064 resultobj = SWIG_Py_Void();
30065 {
30066 if (temp2)
30067 delete arg2;
30068 }
30069 return resultobj;
30070 fail:
30071 {
30072 if (temp2)
30073 delete arg2;
30074 }
30075 return NULL;
30076 }
30077
30078
30079 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30080 PyObject *resultobj = 0;
30081 wxPyApp *arg1 = (wxPyApp *) 0 ;
30082 wxString result;
30083 void *argp1 = 0 ;
30084 int res1 = 0 ;
30085 PyObject *swig_obj[1] ;
30086
30087 if (!args) SWIG_fail;
30088 swig_obj[0] = args;
30089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30090 if (!SWIG_IsOK(res1)) {
30091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30092 }
30093 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30094 {
30095 PyThreadState* __tstate = wxPyBeginAllowThreads();
30096 result = ((wxPyApp const *)arg1)->GetClassName();
30097 wxPyEndAllowThreads(__tstate);
30098 if (PyErr_Occurred()) SWIG_fail;
30099 }
30100 {
30101 #if wxUSE_UNICODE
30102 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30103 #else
30104 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30105 #endif
30106 }
30107 return resultobj;
30108 fail:
30109 return NULL;
30110 }
30111
30112
30113 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30114 PyObject *resultobj = 0;
30115 wxPyApp *arg1 = (wxPyApp *) 0 ;
30116 wxString *arg2 = 0 ;
30117 void *argp1 = 0 ;
30118 int res1 = 0 ;
30119 bool temp2 = false ;
30120 PyObject * obj0 = 0 ;
30121 PyObject * obj1 = 0 ;
30122 char * kwnames[] = {
30123 (char *) "self",(char *) "name", NULL
30124 };
30125
30126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30128 if (!SWIG_IsOK(res1)) {
30129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30130 }
30131 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30132 {
30133 arg2 = wxString_in_helper(obj1);
30134 if (arg2 == NULL) SWIG_fail;
30135 temp2 = true;
30136 }
30137 {
30138 PyThreadState* __tstate = wxPyBeginAllowThreads();
30139 (arg1)->SetClassName((wxString const &)*arg2);
30140 wxPyEndAllowThreads(__tstate);
30141 if (PyErr_Occurred()) SWIG_fail;
30142 }
30143 resultobj = SWIG_Py_Void();
30144 {
30145 if (temp2)
30146 delete arg2;
30147 }
30148 return resultobj;
30149 fail:
30150 {
30151 if (temp2)
30152 delete arg2;
30153 }
30154 return NULL;
30155 }
30156
30157
30158 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30159 PyObject *resultobj = 0;
30160 wxPyApp *arg1 = (wxPyApp *) 0 ;
30161 wxString *result = 0 ;
30162 void *argp1 = 0 ;
30163 int res1 = 0 ;
30164 PyObject *swig_obj[1] ;
30165
30166 if (!args) SWIG_fail;
30167 swig_obj[0] = args;
30168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30169 if (!SWIG_IsOK(res1)) {
30170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30171 }
30172 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30173 {
30174 PyThreadState* __tstate = wxPyBeginAllowThreads();
30175 {
30176 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30177 result = (wxString *) &_result_ref;
30178 }
30179 wxPyEndAllowThreads(__tstate);
30180 if (PyErr_Occurred()) SWIG_fail;
30181 }
30182 {
30183 #if wxUSE_UNICODE
30184 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30185 #else
30186 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30187 #endif
30188 }
30189 return resultobj;
30190 fail:
30191 return NULL;
30192 }
30193
30194
30195 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30196 PyObject *resultobj = 0;
30197 wxPyApp *arg1 = (wxPyApp *) 0 ;
30198 wxString *arg2 = 0 ;
30199 void *argp1 = 0 ;
30200 int res1 = 0 ;
30201 bool temp2 = false ;
30202 PyObject * obj0 = 0 ;
30203 PyObject * obj1 = 0 ;
30204 char * kwnames[] = {
30205 (char *) "self",(char *) "name", NULL
30206 };
30207
30208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30210 if (!SWIG_IsOK(res1)) {
30211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30212 }
30213 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30214 {
30215 arg2 = wxString_in_helper(obj1);
30216 if (arg2 == NULL) SWIG_fail;
30217 temp2 = true;
30218 }
30219 {
30220 PyThreadState* __tstate = wxPyBeginAllowThreads();
30221 (arg1)->SetVendorName((wxString const &)*arg2);
30222 wxPyEndAllowThreads(__tstate);
30223 if (PyErr_Occurred()) SWIG_fail;
30224 }
30225 resultobj = SWIG_Py_Void();
30226 {
30227 if (temp2)
30228 delete arg2;
30229 }
30230 return resultobj;
30231 fail:
30232 {
30233 if (temp2)
30234 delete arg2;
30235 }
30236 return NULL;
30237 }
30238
30239
30240 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30241 PyObject *resultobj = 0;
30242 wxPyApp *arg1 = (wxPyApp *) 0 ;
30243 wxAppTraits *result = 0 ;
30244 void *argp1 = 0 ;
30245 int res1 = 0 ;
30246 PyObject *swig_obj[1] ;
30247
30248 if (!args) SWIG_fail;
30249 swig_obj[0] = args;
30250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30251 if (!SWIG_IsOK(res1)) {
30252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30253 }
30254 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30255 {
30256 PyThreadState* __tstate = wxPyBeginAllowThreads();
30257 result = (wxAppTraits *)(arg1)->GetTraits();
30258 wxPyEndAllowThreads(__tstate);
30259 if (PyErr_Occurred()) SWIG_fail;
30260 }
30261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30262 return resultobj;
30263 fail:
30264 return NULL;
30265 }
30266
30267
30268 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30269 PyObject *resultobj = 0;
30270 wxPyApp *arg1 = (wxPyApp *) 0 ;
30271 void *argp1 = 0 ;
30272 int res1 = 0 ;
30273 PyObject *swig_obj[1] ;
30274
30275 if (!args) SWIG_fail;
30276 swig_obj[0] = args;
30277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30278 if (!SWIG_IsOK(res1)) {
30279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30280 }
30281 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30282 {
30283 PyThreadState* __tstate = wxPyBeginAllowThreads();
30284 (arg1)->ProcessPendingEvents();
30285 wxPyEndAllowThreads(__tstate);
30286 if (PyErr_Occurred()) SWIG_fail;
30287 }
30288 resultobj = SWIG_Py_Void();
30289 return resultobj;
30290 fail:
30291 return NULL;
30292 }
30293
30294
30295 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30296 PyObject *resultobj = 0;
30297 wxPyApp *arg1 = (wxPyApp *) 0 ;
30298 bool arg2 = (bool) false ;
30299 bool result;
30300 void *argp1 = 0 ;
30301 int res1 = 0 ;
30302 bool val2 ;
30303 int ecode2 = 0 ;
30304 PyObject * obj0 = 0 ;
30305 PyObject * obj1 = 0 ;
30306 char * kwnames[] = {
30307 (char *) "self",(char *) "onlyIfNeeded", NULL
30308 };
30309
30310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30312 if (!SWIG_IsOK(res1)) {
30313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30314 }
30315 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30316 if (obj1) {
30317 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30318 if (!SWIG_IsOK(ecode2)) {
30319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30320 }
30321 arg2 = static_cast< bool >(val2);
30322 }
30323 {
30324 PyThreadState* __tstate = wxPyBeginAllowThreads();
30325 result = (bool)(arg1)->Yield(arg2);
30326 wxPyEndAllowThreads(__tstate);
30327 if (PyErr_Occurred()) SWIG_fail;
30328 }
30329 {
30330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30331 }
30332 return resultobj;
30333 fail:
30334 return NULL;
30335 }
30336
30337
30338 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30339 PyObject *resultobj = 0;
30340 wxPyApp *arg1 = (wxPyApp *) 0 ;
30341 void *argp1 = 0 ;
30342 int res1 = 0 ;
30343 PyObject *swig_obj[1] ;
30344
30345 if (!args) SWIG_fail;
30346 swig_obj[0] = args;
30347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30348 if (!SWIG_IsOK(res1)) {
30349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30350 }
30351 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30352 {
30353 PyThreadState* __tstate = wxPyBeginAllowThreads();
30354 (arg1)->WakeUpIdle();
30355 wxPyEndAllowThreads(__tstate);
30356 if (PyErr_Occurred()) SWIG_fail;
30357 }
30358 resultobj = SWIG_Py_Void();
30359 return resultobj;
30360 fail:
30361 return NULL;
30362 }
30363
30364
30365 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30366 PyObject *resultobj = 0;
30367 bool result;
30368
30369 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30370 {
30371 PyThreadState* __tstate = wxPyBeginAllowThreads();
30372 result = (bool)wxPyApp::IsMainLoopRunning();
30373 wxPyEndAllowThreads(__tstate);
30374 if (PyErr_Occurred()) SWIG_fail;
30375 }
30376 {
30377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30378 }
30379 return resultobj;
30380 fail:
30381 return NULL;
30382 }
30383
30384
30385 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30386 PyObject *resultobj = 0;
30387 wxPyApp *arg1 = (wxPyApp *) 0 ;
30388 int result;
30389 void *argp1 = 0 ;
30390 int res1 = 0 ;
30391 PyObject *swig_obj[1] ;
30392
30393 if (!args) SWIG_fail;
30394 swig_obj[0] = args;
30395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30396 if (!SWIG_IsOK(res1)) {
30397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30398 }
30399 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30400 {
30401 PyThreadState* __tstate = wxPyBeginAllowThreads();
30402 result = (int)(arg1)->MainLoop();
30403 wxPyEndAllowThreads(__tstate);
30404 if (PyErr_Occurred()) SWIG_fail;
30405 }
30406 resultobj = SWIG_From_int(static_cast< int >(result));
30407 return resultobj;
30408 fail:
30409 return NULL;
30410 }
30411
30412
30413 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30414 PyObject *resultobj = 0;
30415 wxPyApp *arg1 = (wxPyApp *) 0 ;
30416 void *argp1 = 0 ;
30417 int res1 = 0 ;
30418 PyObject *swig_obj[1] ;
30419
30420 if (!args) SWIG_fail;
30421 swig_obj[0] = args;
30422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30423 if (!SWIG_IsOK(res1)) {
30424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30425 }
30426 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30427 {
30428 PyThreadState* __tstate = wxPyBeginAllowThreads();
30429 (arg1)->Exit();
30430 wxPyEndAllowThreads(__tstate);
30431 if (PyErr_Occurred()) SWIG_fail;
30432 }
30433 resultobj = SWIG_Py_Void();
30434 return resultobj;
30435 fail:
30436 return NULL;
30437 }
30438
30439
30440 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30441 PyObject *resultobj = 0;
30442 wxPyApp *arg1 = (wxPyApp *) 0 ;
30443 wxLayoutDirection result;
30444 void *argp1 = 0 ;
30445 int res1 = 0 ;
30446 PyObject *swig_obj[1] ;
30447
30448 if (!args) SWIG_fail;
30449 swig_obj[0] = args;
30450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30451 if (!SWIG_IsOK(res1)) {
30452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30453 }
30454 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30455 {
30456 PyThreadState* __tstate = wxPyBeginAllowThreads();
30457 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30458 wxPyEndAllowThreads(__tstate);
30459 if (PyErr_Occurred()) SWIG_fail;
30460 }
30461 resultobj = SWIG_From_int(static_cast< int >(result));
30462 return resultobj;
30463 fail:
30464 return NULL;
30465 }
30466
30467
30468 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30469 PyObject *resultobj = 0;
30470 wxPyApp *arg1 = (wxPyApp *) 0 ;
30471 void *argp1 = 0 ;
30472 int res1 = 0 ;
30473 PyObject *swig_obj[1] ;
30474
30475 if (!args) SWIG_fail;
30476 swig_obj[0] = args;
30477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30478 if (!SWIG_IsOK(res1)) {
30479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30480 }
30481 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30482 {
30483 PyThreadState* __tstate = wxPyBeginAllowThreads();
30484 (arg1)->ExitMainLoop();
30485 wxPyEndAllowThreads(__tstate);
30486 if (PyErr_Occurred()) SWIG_fail;
30487 }
30488 resultobj = SWIG_Py_Void();
30489 return resultobj;
30490 fail:
30491 return NULL;
30492 }
30493
30494
30495 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30496 PyObject *resultobj = 0;
30497 wxPyApp *arg1 = (wxPyApp *) 0 ;
30498 bool result;
30499 void *argp1 = 0 ;
30500 int res1 = 0 ;
30501 PyObject *swig_obj[1] ;
30502
30503 if (!args) SWIG_fail;
30504 swig_obj[0] = args;
30505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30506 if (!SWIG_IsOK(res1)) {
30507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30508 }
30509 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30510 {
30511 PyThreadState* __tstate = wxPyBeginAllowThreads();
30512 result = (bool)(arg1)->Pending();
30513 wxPyEndAllowThreads(__tstate);
30514 if (PyErr_Occurred()) SWIG_fail;
30515 }
30516 {
30517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30518 }
30519 return resultobj;
30520 fail:
30521 return NULL;
30522 }
30523
30524
30525 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30526 PyObject *resultobj = 0;
30527 wxPyApp *arg1 = (wxPyApp *) 0 ;
30528 bool result;
30529 void *argp1 = 0 ;
30530 int res1 = 0 ;
30531 PyObject *swig_obj[1] ;
30532
30533 if (!args) SWIG_fail;
30534 swig_obj[0] = args;
30535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30536 if (!SWIG_IsOK(res1)) {
30537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30538 }
30539 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30540 {
30541 PyThreadState* __tstate = wxPyBeginAllowThreads();
30542 result = (bool)(arg1)->Dispatch();
30543 wxPyEndAllowThreads(__tstate);
30544 if (PyErr_Occurred()) SWIG_fail;
30545 }
30546 {
30547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30548 }
30549 return resultobj;
30550 fail:
30551 return NULL;
30552 }
30553
30554
30555 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30556 PyObject *resultobj = 0;
30557 wxPyApp *arg1 = (wxPyApp *) 0 ;
30558 bool result;
30559 void *argp1 = 0 ;
30560 int res1 = 0 ;
30561 PyObject *swig_obj[1] ;
30562
30563 if (!args) SWIG_fail;
30564 swig_obj[0] = args;
30565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30566 if (!SWIG_IsOK(res1)) {
30567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30568 }
30569 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30570 {
30571 PyThreadState* __tstate = wxPyBeginAllowThreads();
30572 result = (bool)(arg1)->ProcessIdle();
30573 wxPyEndAllowThreads(__tstate);
30574 if (PyErr_Occurred()) SWIG_fail;
30575 }
30576 {
30577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30578 }
30579 return resultobj;
30580 fail:
30581 return NULL;
30582 }
30583
30584
30585 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30586 PyObject *resultobj = 0;
30587 wxPyApp *arg1 = (wxPyApp *) 0 ;
30588 wxWindow *arg2 = (wxWindow *) 0 ;
30589 wxIdleEvent *arg3 = 0 ;
30590 bool result;
30591 void *argp1 = 0 ;
30592 int res1 = 0 ;
30593 void *argp2 = 0 ;
30594 int res2 = 0 ;
30595 void *argp3 = 0 ;
30596 int res3 = 0 ;
30597 PyObject * obj0 = 0 ;
30598 PyObject * obj1 = 0 ;
30599 PyObject * obj2 = 0 ;
30600 char * kwnames[] = {
30601 (char *) "self",(char *) "win",(char *) "event", NULL
30602 };
30603
30604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30606 if (!SWIG_IsOK(res1)) {
30607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30608 }
30609 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30610 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30611 if (!SWIG_IsOK(res2)) {
30612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30613 }
30614 arg2 = reinterpret_cast< wxWindow * >(argp2);
30615 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30616 if (!SWIG_IsOK(res3)) {
30617 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30618 }
30619 if (!argp3) {
30620 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30621 }
30622 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30623 {
30624 PyThreadState* __tstate = wxPyBeginAllowThreads();
30625 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30626 wxPyEndAllowThreads(__tstate);
30627 if (PyErr_Occurred()) SWIG_fail;
30628 }
30629 {
30630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30631 }
30632 return resultobj;
30633 fail:
30634 return NULL;
30635 }
30636
30637
30638 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30639 PyObject *resultobj = 0;
30640 wxPyApp *arg1 = (wxPyApp *) 0 ;
30641 bool result;
30642 void *argp1 = 0 ;
30643 int res1 = 0 ;
30644 PyObject *swig_obj[1] ;
30645
30646 if (!args) SWIG_fail;
30647 swig_obj[0] = args;
30648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30649 if (!SWIG_IsOK(res1)) {
30650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30651 }
30652 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30653 {
30654 PyThreadState* __tstate = wxPyBeginAllowThreads();
30655 result = (bool)((wxPyApp const *)arg1)->IsActive();
30656 wxPyEndAllowThreads(__tstate);
30657 if (PyErr_Occurred()) SWIG_fail;
30658 }
30659 {
30660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30661 }
30662 return resultobj;
30663 fail:
30664 return NULL;
30665 }
30666
30667
30668 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30669 PyObject *resultobj = 0;
30670 wxPyApp *arg1 = (wxPyApp *) 0 ;
30671 wxWindow *arg2 = (wxWindow *) 0 ;
30672 void *argp1 = 0 ;
30673 int res1 = 0 ;
30674 void *argp2 = 0 ;
30675 int res2 = 0 ;
30676 PyObject * obj0 = 0 ;
30677 PyObject * obj1 = 0 ;
30678 char * kwnames[] = {
30679 (char *) "self",(char *) "win", NULL
30680 };
30681
30682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30684 if (!SWIG_IsOK(res1)) {
30685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30686 }
30687 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30688 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30689 if (!SWIG_IsOK(res2)) {
30690 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30691 }
30692 arg2 = reinterpret_cast< wxWindow * >(argp2);
30693 {
30694 PyThreadState* __tstate = wxPyBeginAllowThreads();
30695 (arg1)->SetTopWindow(arg2);
30696 wxPyEndAllowThreads(__tstate);
30697 if (PyErr_Occurred()) SWIG_fail;
30698 }
30699 resultobj = SWIG_Py_Void();
30700 return resultobj;
30701 fail:
30702 return NULL;
30703 }
30704
30705
30706 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30707 PyObject *resultobj = 0;
30708 wxPyApp *arg1 = (wxPyApp *) 0 ;
30709 wxWindow *result = 0 ;
30710 void *argp1 = 0 ;
30711 int res1 = 0 ;
30712 PyObject *swig_obj[1] ;
30713
30714 if (!args) SWIG_fail;
30715 swig_obj[0] = args;
30716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30717 if (!SWIG_IsOK(res1)) {
30718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30719 }
30720 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30721 {
30722 PyThreadState* __tstate = wxPyBeginAllowThreads();
30723 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30724 wxPyEndAllowThreads(__tstate);
30725 if (PyErr_Occurred()) SWIG_fail;
30726 }
30727 {
30728 resultobj = wxPyMake_wxObject(result, (bool)0);
30729 }
30730 return resultobj;
30731 fail:
30732 return NULL;
30733 }
30734
30735
30736 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30737 PyObject *resultobj = 0;
30738 wxPyApp *arg1 = (wxPyApp *) 0 ;
30739 bool arg2 ;
30740 void *argp1 = 0 ;
30741 int res1 = 0 ;
30742 bool val2 ;
30743 int ecode2 = 0 ;
30744 PyObject * obj0 = 0 ;
30745 PyObject * obj1 = 0 ;
30746 char * kwnames[] = {
30747 (char *) "self",(char *) "flag", NULL
30748 };
30749
30750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30752 if (!SWIG_IsOK(res1)) {
30753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30754 }
30755 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30756 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30757 if (!SWIG_IsOK(ecode2)) {
30758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30759 }
30760 arg2 = static_cast< bool >(val2);
30761 {
30762 PyThreadState* __tstate = wxPyBeginAllowThreads();
30763 (arg1)->SetExitOnFrameDelete(arg2);
30764 wxPyEndAllowThreads(__tstate);
30765 if (PyErr_Occurred()) SWIG_fail;
30766 }
30767 resultobj = SWIG_Py_Void();
30768 return resultobj;
30769 fail:
30770 return NULL;
30771 }
30772
30773
30774 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30775 PyObject *resultobj = 0;
30776 wxPyApp *arg1 = (wxPyApp *) 0 ;
30777 bool result;
30778 void *argp1 = 0 ;
30779 int res1 = 0 ;
30780 PyObject *swig_obj[1] ;
30781
30782 if (!args) SWIG_fail;
30783 swig_obj[0] = args;
30784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30785 if (!SWIG_IsOK(res1)) {
30786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30787 }
30788 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30789 {
30790 PyThreadState* __tstate = wxPyBeginAllowThreads();
30791 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30792 wxPyEndAllowThreads(__tstate);
30793 if (PyErr_Occurred()) SWIG_fail;
30794 }
30795 {
30796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30797 }
30798 return resultobj;
30799 fail:
30800 return NULL;
30801 }
30802
30803
30804 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30805 PyObject *resultobj = 0;
30806 wxPyApp *arg1 = (wxPyApp *) 0 ;
30807 bool arg2 ;
30808 bool arg3 = (bool) false ;
30809 void *argp1 = 0 ;
30810 int res1 = 0 ;
30811 bool val2 ;
30812 int ecode2 = 0 ;
30813 bool val3 ;
30814 int ecode3 = 0 ;
30815 PyObject * obj0 = 0 ;
30816 PyObject * obj1 = 0 ;
30817 PyObject * obj2 = 0 ;
30818 char * kwnames[] = {
30819 (char *) "self",(char *) "flag",(char *) "forceTrueColour", NULL
30820 };
30821
30822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30824 if (!SWIG_IsOK(res1)) {
30825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
30826 }
30827 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30828 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30829 if (!SWIG_IsOK(ecode2)) {
30830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
30831 }
30832 arg2 = static_cast< bool >(val2);
30833 if (obj2) {
30834 ecode3 = SWIG_AsVal_bool(obj2, &val3);
30835 if (!SWIG_IsOK(ecode3)) {
30836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "3"" of type '" "bool""'");
30837 }
30838 arg3 = static_cast< bool >(val3);
30839 }
30840 {
30841 PyThreadState* __tstate = wxPyBeginAllowThreads();
30842 (arg1)->SetUseBestVisual(arg2,arg3);
30843 wxPyEndAllowThreads(__tstate);
30844 if (PyErr_Occurred()) SWIG_fail;
30845 }
30846 resultobj = SWIG_Py_Void();
30847 return resultobj;
30848 fail:
30849 return NULL;
30850 }
30851
30852
30853 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30854 PyObject *resultobj = 0;
30855 wxPyApp *arg1 = (wxPyApp *) 0 ;
30856 bool result;
30857 void *argp1 = 0 ;
30858 int res1 = 0 ;
30859 PyObject *swig_obj[1] ;
30860
30861 if (!args) SWIG_fail;
30862 swig_obj[0] = args;
30863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30864 if (!SWIG_IsOK(res1)) {
30865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30866 }
30867 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30868 {
30869 PyThreadState* __tstate = wxPyBeginAllowThreads();
30870 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
30871 wxPyEndAllowThreads(__tstate);
30872 if (PyErr_Occurred()) SWIG_fail;
30873 }
30874 {
30875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30876 }
30877 return resultobj;
30878 fail:
30879 return NULL;
30880 }
30881
30882
30883 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30884 PyObject *resultobj = 0;
30885 wxPyApp *arg1 = (wxPyApp *) 0 ;
30886 int arg2 ;
30887 void *argp1 = 0 ;
30888 int res1 = 0 ;
30889 int val2 ;
30890 int ecode2 = 0 ;
30891 PyObject * obj0 = 0 ;
30892 PyObject * obj1 = 0 ;
30893 char * kwnames[] = {
30894 (char *) "self",(char *) "mode", NULL
30895 };
30896
30897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
30898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30899 if (!SWIG_IsOK(res1)) {
30900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30901 }
30902 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30903 ecode2 = SWIG_AsVal_int(obj1, &val2);
30904 if (!SWIG_IsOK(ecode2)) {
30905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
30906 }
30907 arg2 = static_cast< int >(val2);
30908 {
30909 PyThreadState* __tstate = wxPyBeginAllowThreads();
30910 (arg1)->SetPrintMode(arg2);
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_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30922 PyObject *resultobj = 0;
30923 wxPyApp *arg1 = (wxPyApp *) 0 ;
30924 int result;
30925 void *argp1 = 0 ;
30926 int res1 = 0 ;
30927 PyObject *swig_obj[1] ;
30928
30929 if (!args) SWIG_fail;
30930 swig_obj[0] = args;
30931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30932 if (!SWIG_IsOK(res1)) {
30933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30934 }
30935 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30936 {
30937 PyThreadState* __tstate = wxPyBeginAllowThreads();
30938 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
30939 wxPyEndAllowThreads(__tstate);
30940 if (PyErr_Occurred()) SWIG_fail;
30941 }
30942 resultobj = SWIG_From_int(static_cast< int >(result));
30943 return resultobj;
30944 fail:
30945 return NULL;
30946 }
30947
30948
30949 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30950 PyObject *resultobj = 0;
30951 wxPyApp *arg1 = (wxPyApp *) 0 ;
30952 int arg2 ;
30953 void *argp1 = 0 ;
30954 int res1 = 0 ;
30955 int val2 ;
30956 int ecode2 = 0 ;
30957 PyObject * obj0 = 0 ;
30958 PyObject * obj1 = 0 ;
30959 char * kwnames[] = {
30960 (char *) "self",(char *) "mode", NULL
30961 };
30962
30963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
30964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30965 if (!SWIG_IsOK(res1)) {
30966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30967 }
30968 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30969 ecode2 = SWIG_AsVal_int(obj1, &val2);
30970 if (!SWIG_IsOK(ecode2)) {
30971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
30972 }
30973 arg2 = static_cast< int >(val2);
30974 {
30975 PyThreadState* __tstate = wxPyBeginAllowThreads();
30976 (arg1)->SetAssertMode(arg2);
30977 wxPyEndAllowThreads(__tstate);
30978 if (PyErr_Occurred()) SWIG_fail;
30979 }
30980 resultobj = SWIG_Py_Void();
30981 return resultobj;
30982 fail:
30983 return NULL;
30984 }
30985
30986
30987 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30988 PyObject *resultobj = 0;
30989 wxPyApp *arg1 = (wxPyApp *) 0 ;
30990 int result;
30991 void *argp1 = 0 ;
30992 int res1 = 0 ;
30993 PyObject *swig_obj[1] ;
30994
30995 if (!args) SWIG_fail;
30996 swig_obj[0] = args;
30997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30998 if (!SWIG_IsOK(res1)) {
30999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31000 }
31001 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31002 {
31003 PyThreadState* __tstate = wxPyBeginAllowThreads();
31004 result = (int)(arg1)->GetAssertMode();
31005 wxPyEndAllowThreads(__tstate);
31006 if (PyErr_Occurred()) SWIG_fail;
31007 }
31008 resultobj = SWIG_From_int(static_cast< int >(result));
31009 return resultobj;
31010 fail:
31011 return NULL;
31012 }
31013
31014
31015 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31016 PyObject *resultobj = 0;
31017 bool result;
31018
31019 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31020 {
31021 PyThreadState* __tstate = wxPyBeginAllowThreads();
31022 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31023 wxPyEndAllowThreads(__tstate);
31024 if (PyErr_Occurred()) SWIG_fail;
31025 }
31026 {
31027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31028 }
31029 return resultobj;
31030 fail:
31031 return NULL;
31032 }
31033
31034
31035 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31036 PyObject *resultobj = 0;
31037 long result;
31038
31039 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31040 {
31041 PyThreadState* __tstate = wxPyBeginAllowThreads();
31042 result = (long)wxPyApp::GetMacAboutMenuItemId();
31043 wxPyEndAllowThreads(__tstate);
31044 if (PyErr_Occurred()) SWIG_fail;
31045 }
31046 resultobj = SWIG_From_long(static_cast< long >(result));
31047 return resultobj;
31048 fail:
31049 return NULL;
31050 }
31051
31052
31053 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31054 PyObject *resultobj = 0;
31055 long result;
31056
31057 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31058 {
31059 PyThreadState* __tstate = wxPyBeginAllowThreads();
31060 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31061 wxPyEndAllowThreads(__tstate);
31062 if (PyErr_Occurred()) SWIG_fail;
31063 }
31064 resultobj = SWIG_From_long(static_cast< long >(result));
31065 return resultobj;
31066 fail:
31067 return NULL;
31068 }
31069
31070
31071 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31072 PyObject *resultobj = 0;
31073 long result;
31074
31075 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31076 {
31077 PyThreadState* __tstate = wxPyBeginAllowThreads();
31078 result = (long)wxPyApp::GetMacExitMenuItemId();
31079 wxPyEndAllowThreads(__tstate);
31080 if (PyErr_Occurred()) SWIG_fail;
31081 }
31082 resultobj = SWIG_From_long(static_cast< long >(result));
31083 return resultobj;
31084 fail:
31085 return NULL;
31086 }
31087
31088
31089 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31090 PyObject *resultobj = 0;
31091 wxString result;
31092
31093 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31094 {
31095 PyThreadState* __tstate = wxPyBeginAllowThreads();
31096 result = wxPyApp::GetMacHelpMenuTitleName();
31097 wxPyEndAllowThreads(__tstate);
31098 if (PyErr_Occurred()) SWIG_fail;
31099 }
31100 {
31101 #if wxUSE_UNICODE
31102 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31103 #else
31104 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31105 #endif
31106 }
31107 return resultobj;
31108 fail:
31109 return NULL;
31110 }
31111
31112
31113 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31114 PyObject *resultobj = 0;
31115 bool arg1 ;
31116 bool val1 ;
31117 int ecode1 = 0 ;
31118 PyObject * obj0 = 0 ;
31119 char * kwnames[] = {
31120 (char *) "val", NULL
31121 };
31122
31123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31124 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31125 if (!SWIG_IsOK(ecode1)) {
31126 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31127 }
31128 arg1 = static_cast< bool >(val1);
31129 {
31130 PyThreadState* __tstate = wxPyBeginAllowThreads();
31131 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31132 wxPyEndAllowThreads(__tstate);
31133 if (PyErr_Occurred()) SWIG_fail;
31134 }
31135 resultobj = SWIG_Py_Void();
31136 return resultobj;
31137 fail:
31138 return NULL;
31139 }
31140
31141
31142 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31143 PyObject *resultobj = 0;
31144 long arg1 ;
31145 long val1 ;
31146 int ecode1 = 0 ;
31147 PyObject * obj0 = 0 ;
31148 char * kwnames[] = {
31149 (char *) "val", NULL
31150 };
31151
31152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31153 ecode1 = SWIG_AsVal_long(obj0, &val1);
31154 if (!SWIG_IsOK(ecode1)) {
31155 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31156 }
31157 arg1 = static_cast< long >(val1);
31158 {
31159 PyThreadState* __tstate = wxPyBeginAllowThreads();
31160 wxPyApp::SetMacAboutMenuItemId(arg1);
31161 wxPyEndAllowThreads(__tstate);
31162 if (PyErr_Occurred()) SWIG_fail;
31163 }
31164 resultobj = SWIG_Py_Void();
31165 return resultobj;
31166 fail:
31167 return NULL;
31168 }
31169
31170
31171 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31172 PyObject *resultobj = 0;
31173 long arg1 ;
31174 long val1 ;
31175 int ecode1 = 0 ;
31176 PyObject * obj0 = 0 ;
31177 char * kwnames[] = {
31178 (char *) "val", NULL
31179 };
31180
31181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31182 ecode1 = SWIG_AsVal_long(obj0, &val1);
31183 if (!SWIG_IsOK(ecode1)) {
31184 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31185 }
31186 arg1 = static_cast< long >(val1);
31187 {
31188 PyThreadState* __tstate = wxPyBeginAllowThreads();
31189 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31190 wxPyEndAllowThreads(__tstate);
31191 if (PyErr_Occurred()) SWIG_fail;
31192 }
31193 resultobj = SWIG_Py_Void();
31194 return resultobj;
31195 fail:
31196 return NULL;
31197 }
31198
31199
31200 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31201 PyObject *resultobj = 0;
31202 long arg1 ;
31203 long val1 ;
31204 int ecode1 = 0 ;
31205 PyObject * obj0 = 0 ;
31206 char * kwnames[] = {
31207 (char *) "val", NULL
31208 };
31209
31210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31211 ecode1 = SWIG_AsVal_long(obj0, &val1);
31212 if (!SWIG_IsOK(ecode1)) {
31213 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31214 }
31215 arg1 = static_cast< long >(val1);
31216 {
31217 PyThreadState* __tstate = wxPyBeginAllowThreads();
31218 wxPyApp::SetMacExitMenuItemId(arg1);
31219 wxPyEndAllowThreads(__tstate);
31220 if (PyErr_Occurred()) SWIG_fail;
31221 }
31222 resultobj = SWIG_Py_Void();
31223 return resultobj;
31224 fail:
31225 return NULL;
31226 }
31227
31228
31229 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31230 PyObject *resultobj = 0;
31231 wxString *arg1 = 0 ;
31232 bool temp1 = false ;
31233 PyObject * obj0 = 0 ;
31234 char * kwnames[] = {
31235 (char *) "val", NULL
31236 };
31237
31238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31239 {
31240 arg1 = wxString_in_helper(obj0);
31241 if (arg1 == NULL) SWIG_fail;
31242 temp1 = true;
31243 }
31244 {
31245 PyThreadState* __tstate = wxPyBeginAllowThreads();
31246 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31247 wxPyEndAllowThreads(__tstate);
31248 if (PyErr_Occurred()) SWIG_fail;
31249 }
31250 resultobj = SWIG_Py_Void();
31251 {
31252 if (temp1)
31253 delete arg1;
31254 }
31255 return resultobj;
31256 fail:
31257 {
31258 if (temp1)
31259 delete arg1;
31260 }
31261 return NULL;
31262 }
31263
31264
31265 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31266 PyObject *resultobj = 0;
31267 wxPyApp *arg1 = (wxPyApp *) 0 ;
31268 void *argp1 = 0 ;
31269 int res1 = 0 ;
31270 PyObject *swig_obj[1] ;
31271
31272 if (!args) SWIG_fail;
31273 swig_obj[0] = args;
31274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31275 if (!SWIG_IsOK(res1)) {
31276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31277 }
31278 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31279 {
31280 PyThreadState* __tstate = wxPyBeginAllowThreads();
31281 (arg1)->_BootstrapApp();
31282 wxPyEndAllowThreads(__tstate);
31283 if (PyErr_Occurred()) SWIG_fail;
31284 }
31285 resultobj = SWIG_Py_Void();
31286 return resultobj;
31287 fail:
31288 return NULL;
31289 }
31290
31291
31292 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31293 PyObject *resultobj = 0;
31294 int result;
31295
31296 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31297 {
31298 PyThreadState* __tstate = wxPyBeginAllowThreads();
31299 result = (int)wxPyApp_GetComCtl32Version();
31300 wxPyEndAllowThreads(__tstate);
31301 if (PyErr_Occurred()) SWIG_fail;
31302 }
31303 resultobj = SWIG_From_int(static_cast< int >(result));
31304 return resultobj;
31305 fail:
31306 return NULL;
31307 }
31308
31309
31310 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31311 PyObject *resultobj = 0;
31312 bool result;
31313
31314 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31315 {
31316 PyThreadState* __tstate = wxPyBeginAllowThreads();
31317 result = (bool)wxPyApp_IsDisplayAvailable();
31318 wxPyEndAllowThreads(__tstate);
31319 if (PyErr_Occurred()) SWIG_fail;
31320 }
31321 {
31322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31323 }
31324 return resultobj;
31325 fail:
31326 return NULL;
31327 }
31328
31329
31330 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31331 PyObject *obj;
31332 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31333 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31334 return SWIG_Py_Void();
31335 }
31336
31337 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31338 return SWIG_Python_InitShadowInstance(args);
31339 }
31340
31341 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31342 PyObject *resultobj = 0;
31343
31344 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31345 {
31346 PyThreadState* __tstate = wxPyBeginAllowThreads();
31347 wxExit();
31348 wxPyEndAllowThreads(__tstate);
31349 if (PyErr_Occurred()) SWIG_fail;
31350 }
31351 resultobj = SWIG_Py_Void();
31352 return resultobj;
31353 fail:
31354 return NULL;
31355 }
31356
31357
31358 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31359 PyObject *resultobj = 0;
31360 bool result;
31361
31362 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31363 {
31364 PyThreadState* __tstate = wxPyBeginAllowThreads();
31365 result = (bool)wxYield();
31366 wxPyEndAllowThreads(__tstate);
31367 if (PyErr_Occurred()) SWIG_fail;
31368 }
31369 {
31370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31371 }
31372 return resultobj;
31373 fail:
31374 return NULL;
31375 }
31376
31377
31378 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31379 PyObject *resultobj = 0;
31380 bool result;
31381
31382 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31383 {
31384 PyThreadState* __tstate = wxPyBeginAllowThreads();
31385 result = (bool)wxYieldIfNeeded();
31386 wxPyEndAllowThreads(__tstate);
31387 if (PyErr_Occurred()) SWIG_fail;
31388 }
31389 {
31390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31391 }
31392 return resultobj;
31393 fail:
31394 return NULL;
31395 }
31396
31397
31398 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31399 PyObject *resultobj = 0;
31400 wxWindow *arg1 = (wxWindow *) NULL ;
31401 bool arg2 = (bool) false ;
31402 bool result;
31403 void *argp1 = 0 ;
31404 int res1 = 0 ;
31405 bool val2 ;
31406 int ecode2 = 0 ;
31407 PyObject * obj0 = 0 ;
31408 PyObject * obj1 = 0 ;
31409 char * kwnames[] = {
31410 (char *) "win",(char *) "onlyIfNeeded", NULL
31411 };
31412
31413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31414 if (obj0) {
31415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31416 if (!SWIG_IsOK(res1)) {
31417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31418 }
31419 arg1 = reinterpret_cast< wxWindow * >(argp1);
31420 }
31421 if (obj1) {
31422 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31423 if (!SWIG_IsOK(ecode2)) {
31424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31425 }
31426 arg2 = static_cast< bool >(val2);
31427 }
31428 {
31429 PyThreadState* __tstate = wxPyBeginAllowThreads();
31430 result = (bool)wxSafeYield(arg1,arg2);
31431 wxPyEndAllowThreads(__tstate);
31432 if (PyErr_Occurred()) SWIG_fail;
31433 }
31434 {
31435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31436 }
31437 return resultobj;
31438 fail:
31439 return NULL;
31440 }
31441
31442
31443 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31444 PyObject *resultobj = 0;
31445
31446 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31447 {
31448 PyThreadState* __tstate = wxPyBeginAllowThreads();
31449 wxWakeUpIdle();
31450 wxPyEndAllowThreads(__tstate);
31451 if (PyErr_Occurred()) SWIG_fail;
31452 }
31453 resultobj = SWIG_Py_Void();
31454 return resultobj;
31455 fail:
31456 return NULL;
31457 }
31458
31459
31460 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31461 PyObject *resultobj = 0;
31462 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31463 wxEvent *arg2 = 0 ;
31464 void *argp1 = 0 ;
31465 int res1 = 0 ;
31466 void *argp2 = 0 ;
31467 int res2 = 0 ;
31468 PyObject * obj0 = 0 ;
31469 PyObject * obj1 = 0 ;
31470 char * kwnames[] = {
31471 (char *) "dest",(char *) "event", NULL
31472 };
31473
31474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31476 if (!SWIG_IsOK(res1)) {
31477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31478 }
31479 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31480 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31481 if (!SWIG_IsOK(res2)) {
31482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31483 }
31484 if (!argp2) {
31485 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31486 }
31487 arg2 = reinterpret_cast< wxEvent * >(argp2);
31488 {
31489 PyThreadState* __tstate = wxPyBeginAllowThreads();
31490 wxPostEvent(arg1,*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_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31502 PyObject *resultobj = 0;
31503
31504 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31505 {
31506 PyThreadState* __tstate = wxPyBeginAllowThreads();
31507 wxApp_CleanUp();
31508 wxPyEndAllowThreads(__tstate);
31509 if (PyErr_Occurred()) SWIG_fail;
31510 }
31511 resultobj = SWIG_Py_Void();
31512 return resultobj;
31513 fail:
31514 return NULL;
31515 }
31516
31517
31518 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31519 PyObject *resultobj = 0;
31520 wxPyApp *result = 0 ;
31521
31522 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31523 {
31524 PyThreadState* __tstate = wxPyBeginAllowThreads();
31525 result = (wxPyApp *)wxPyGetApp();
31526 wxPyEndAllowThreads(__tstate);
31527 if (PyErr_Occurred()) SWIG_fail;
31528 }
31529 {
31530 resultobj = wxPyMake_wxObject(result, 0);
31531 }
31532 return resultobj;
31533 fail:
31534 return NULL;
31535 }
31536
31537
31538 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31539 PyObject *resultobj = 0;
31540 char *arg1 = (char *) 0 ;
31541 int res1 ;
31542 char *buf1 = 0 ;
31543 int alloc1 = 0 ;
31544 PyObject * obj0 = 0 ;
31545 char * kwnames[] = {
31546 (char *) "encoding", NULL
31547 };
31548
31549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31550 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31551 if (!SWIG_IsOK(res1)) {
31552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31553 }
31554 arg1 = buf1;
31555 {
31556 PyThreadState* __tstate = wxPyBeginAllowThreads();
31557 wxSetDefaultPyEncoding((char const *)arg1);
31558 wxPyEndAllowThreads(__tstate);
31559 if (PyErr_Occurred()) SWIG_fail;
31560 }
31561 resultobj = SWIG_Py_Void();
31562 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31563 return resultobj;
31564 fail:
31565 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31566 return NULL;
31567 }
31568
31569
31570 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31571 PyObject *resultobj = 0;
31572 char *result = 0 ;
31573
31574 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31575 {
31576 PyThreadState* __tstate = wxPyBeginAllowThreads();
31577 result = (char *)wxGetDefaultPyEncoding();
31578 wxPyEndAllowThreads(__tstate);
31579 if (PyErr_Occurred()) SWIG_fail;
31580 }
31581 resultobj = SWIG_FromCharPtr(result);
31582 return resultobj;
31583 fail:
31584 return NULL;
31585 }
31586
31587
31588 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31589 PyObject *resultobj = 0;
31590 wxEventLoop *result = 0 ;
31591
31592 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31593 {
31594 PyThreadState* __tstate = wxPyBeginAllowThreads();
31595 result = (wxEventLoop *)new wxEventLoop();
31596 wxPyEndAllowThreads(__tstate);
31597 if (PyErr_Occurred()) SWIG_fail;
31598 }
31599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31600 return resultobj;
31601 fail:
31602 return NULL;
31603 }
31604
31605
31606 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31607 PyObject *resultobj = 0;
31608 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31609 void *argp1 = 0 ;
31610 int res1 = 0 ;
31611 PyObject *swig_obj[1] ;
31612
31613 if (!args) SWIG_fail;
31614 swig_obj[0] = args;
31615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31616 if (!SWIG_IsOK(res1)) {
31617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31618 }
31619 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31620 {
31621 PyThreadState* __tstate = wxPyBeginAllowThreads();
31622 delete arg1;
31623
31624 wxPyEndAllowThreads(__tstate);
31625 if (PyErr_Occurred()) SWIG_fail;
31626 }
31627 resultobj = SWIG_Py_Void();
31628 return resultobj;
31629 fail:
31630 return NULL;
31631 }
31632
31633
31634 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31635 PyObject *resultobj = 0;
31636 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31637 int result;
31638 void *argp1 = 0 ;
31639 int res1 = 0 ;
31640 PyObject *swig_obj[1] ;
31641
31642 if (!args) SWIG_fail;
31643 swig_obj[0] = args;
31644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31645 if (!SWIG_IsOK(res1)) {
31646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31647 }
31648 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31649 {
31650 PyThreadState* __tstate = wxPyBeginAllowThreads();
31651 result = (int)(arg1)->Run();
31652 wxPyEndAllowThreads(__tstate);
31653 if (PyErr_Occurred()) SWIG_fail;
31654 }
31655 resultobj = SWIG_From_int(static_cast< int >(result));
31656 return resultobj;
31657 fail:
31658 return NULL;
31659 }
31660
31661
31662 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31663 PyObject *resultobj = 0;
31664 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31665 int arg2 = (int) 0 ;
31666 void *argp1 = 0 ;
31667 int res1 = 0 ;
31668 int val2 ;
31669 int ecode2 = 0 ;
31670 PyObject * obj0 = 0 ;
31671 PyObject * obj1 = 0 ;
31672 char * kwnames[] = {
31673 (char *) "self",(char *) "rc", NULL
31674 };
31675
31676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31678 if (!SWIG_IsOK(res1)) {
31679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31680 }
31681 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31682 if (obj1) {
31683 ecode2 = SWIG_AsVal_int(obj1, &val2);
31684 if (!SWIG_IsOK(ecode2)) {
31685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31686 }
31687 arg2 = static_cast< int >(val2);
31688 }
31689 {
31690 PyThreadState* __tstate = wxPyBeginAllowThreads();
31691 (arg1)->Exit(arg2);
31692 wxPyEndAllowThreads(__tstate);
31693 if (PyErr_Occurred()) SWIG_fail;
31694 }
31695 resultobj = SWIG_Py_Void();
31696 return resultobj;
31697 fail:
31698 return NULL;
31699 }
31700
31701
31702 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31703 PyObject *resultobj = 0;
31704 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31705 bool result;
31706 void *argp1 = 0 ;
31707 int res1 = 0 ;
31708 PyObject *swig_obj[1] ;
31709
31710 if (!args) SWIG_fail;
31711 swig_obj[0] = args;
31712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31713 if (!SWIG_IsOK(res1)) {
31714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31715 }
31716 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31717 {
31718 PyThreadState* __tstate = wxPyBeginAllowThreads();
31719 result = (bool)((wxEventLoop const *)arg1)->Pending();
31720 wxPyEndAllowThreads(__tstate);
31721 if (PyErr_Occurred()) SWIG_fail;
31722 }
31723 {
31724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31725 }
31726 return resultobj;
31727 fail:
31728 return NULL;
31729 }
31730
31731
31732 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31733 PyObject *resultobj = 0;
31734 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31735 bool 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_wxEventLoop, 0 | 0 );
31743 if (!SWIG_IsOK(res1)) {
31744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31745 }
31746 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31747 {
31748 PyThreadState* __tstate = wxPyBeginAllowThreads();
31749 result = (bool)(arg1)->Dispatch();
31750 wxPyEndAllowThreads(__tstate);
31751 if (PyErr_Occurred()) SWIG_fail;
31752 }
31753 {
31754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31755 }
31756 return resultobj;
31757 fail:
31758 return NULL;
31759 }
31760
31761
31762 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31763 PyObject *resultobj = 0;
31764 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31765 bool result;
31766 void *argp1 = 0 ;
31767 int res1 = 0 ;
31768 PyObject *swig_obj[1] ;
31769
31770 if (!args) SWIG_fail;
31771 swig_obj[0] = args;
31772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31773 if (!SWIG_IsOK(res1)) {
31774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31775 }
31776 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31777 {
31778 PyThreadState* __tstate = wxPyBeginAllowThreads();
31779 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31780 wxPyEndAllowThreads(__tstate);
31781 if (PyErr_Occurred()) SWIG_fail;
31782 }
31783 {
31784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31785 }
31786 return resultobj;
31787 fail:
31788 return NULL;
31789 }
31790
31791
31792 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31793 PyObject *resultobj = 0;
31794 wxEventLoop *result = 0 ;
31795
31796 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31797 {
31798 PyThreadState* __tstate = wxPyBeginAllowThreads();
31799 result = (wxEventLoop *)wxEventLoop::GetActive();
31800 wxPyEndAllowThreads(__tstate);
31801 if (PyErr_Occurred()) SWIG_fail;
31802 }
31803 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
31804 return resultobj;
31805 fail:
31806 return NULL;
31807 }
31808
31809
31810 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31811 PyObject *resultobj = 0;
31812 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31813 void *argp1 = 0 ;
31814 int res1 = 0 ;
31815 PyObject * obj0 = 0 ;
31816 char * kwnames[] = {
31817 (char *) "loop", NULL
31818 };
31819
31820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
31821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31822 if (!SWIG_IsOK(res1)) {
31823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31824 }
31825 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31826 {
31827 PyThreadState* __tstate = wxPyBeginAllowThreads();
31828 wxEventLoop::SetActive(arg1);
31829 wxPyEndAllowThreads(__tstate);
31830 if (PyErr_Occurred()) SWIG_fail;
31831 }
31832 resultobj = SWIG_Py_Void();
31833 return resultobj;
31834 fail:
31835 return NULL;
31836 }
31837
31838
31839 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31840 PyObject *obj;
31841 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31842 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
31843 return SWIG_Py_Void();
31844 }
31845
31846 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31847 return SWIG_Python_InitShadowInstance(args);
31848 }
31849
31850 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31851 PyObject *resultobj = 0;
31852 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31853 wxEventLoopActivator *result = 0 ;
31854 void *argp1 = 0 ;
31855 int res1 = 0 ;
31856 PyObject * obj0 = 0 ;
31857 char * kwnames[] = {
31858 (char *) "evtLoop", NULL
31859 };
31860
31861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
31862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31863 if (!SWIG_IsOK(res1)) {
31864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31865 }
31866 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31867 {
31868 PyThreadState* __tstate = wxPyBeginAllowThreads();
31869 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
31870 wxPyEndAllowThreads(__tstate);
31871 if (PyErr_Occurred()) SWIG_fail;
31872 }
31873 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
31874 return resultobj;
31875 fail:
31876 return NULL;
31877 }
31878
31879
31880 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31881 PyObject *resultobj = 0;
31882 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
31883 void *argp1 = 0 ;
31884 int res1 = 0 ;
31885 PyObject *swig_obj[1] ;
31886
31887 if (!args) SWIG_fail;
31888 swig_obj[0] = args;
31889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
31890 if (!SWIG_IsOK(res1)) {
31891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
31892 }
31893 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
31894 {
31895 PyThreadState* __tstate = wxPyBeginAllowThreads();
31896 delete arg1;
31897
31898 wxPyEndAllowThreads(__tstate);
31899 if (PyErr_Occurred()) SWIG_fail;
31900 }
31901 resultobj = SWIG_Py_Void();
31902 return resultobj;
31903 fail:
31904 return NULL;
31905 }
31906
31907
31908 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31909 PyObject *obj;
31910 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31911 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
31912 return SWIG_Py_Void();
31913 }
31914
31915 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31916 return SWIG_Python_InitShadowInstance(args);
31917 }
31918
31919 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31920 PyObject *resultobj = 0;
31921 int arg1 = (int) 0 ;
31922 int arg2 = (int) 0 ;
31923 int arg3 = (int) 0 ;
31924 wxAcceleratorEntry *result = 0 ;
31925 int val1 ;
31926 int ecode1 = 0 ;
31927 int val2 ;
31928 int ecode2 = 0 ;
31929 int val3 ;
31930 int ecode3 = 0 ;
31931 PyObject * obj0 = 0 ;
31932 PyObject * obj1 = 0 ;
31933 PyObject * obj2 = 0 ;
31934 char * kwnames[] = {
31935 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
31936 };
31937
31938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31939 if (obj0) {
31940 ecode1 = SWIG_AsVal_int(obj0, &val1);
31941 if (!SWIG_IsOK(ecode1)) {
31942 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
31943 }
31944 arg1 = static_cast< int >(val1);
31945 }
31946 if (obj1) {
31947 ecode2 = SWIG_AsVal_int(obj1, &val2);
31948 if (!SWIG_IsOK(ecode2)) {
31949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
31950 }
31951 arg2 = static_cast< int >(val2);
31952 }
31953 if (obj2) {
31954 ecode3 = SWIG_AsVal_int(obj2, &val3);
31955 if (!SWIG_IsOK(ecode3)) {
31956 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
31957 }
31958 arg3 = static_cast< int >(val3);
31959 }
31960 {
31961 PyThreadState* __tstate = wxPyBeginAllowThreads();
31962 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
31963 wxPyEndAllowThreads(__tstate);
31964 if (PyErr_Occurred()) SWIG_fail;
31965 }
31966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
31967 return resultobj;
31968 fail:
31969 return NULL;
31970 }
31971
31972
31973 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31974 PyObject *resultobj = 0;
31975 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
31976 void *argp1 = 0 ;
31977 int res1 = 0 ;
31978 PyObject *swig_obj[1] ;
31979
31980 if (!args) SWIG_fail;
31981 swig_obj[0] = args;
31982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
31983 if (!SWIG_IsOK(res1)) {
31984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
31985 }
31986 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
31987 {
31988 PyThreadState* __tstate = wxPyBeginAllowThreads();
31989 delete arg1;
31990
31991 wxPyEndAllowThreads(__tstate);
31992 if (PyErr_Occurred()) SWIG_fail;
31993 }
31994 resultobj = SWIG_Py_Void();
31995 return resultobj;
31996 fail:
31997 return NULL;
31998 }
31999
32000
32001 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32002 PyObject *resultobj = 0;
32003 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32004 int arg2 ;
32005 int arg3 ;
32006 int arg4 ;
32007 void *argp1 = 0 ;
32008 int res1 = 0 ;
32009 int val2 ;
32010 int ecode2 = 0 ;
32011 int val3 ;
32012 int ecode3 = 0 ;
32013 int val4 ;
32014 int ecode4 = 0 ;
32015 PyObject * obj0 = 0 ;
32016 PyObject * obj1 = 0 ;
32017 PyObject * obj2 = 0 ;
32018 PyObject * obj3 = 0 ;
32019 char * kwnames[] = {
32020 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32021 };
32022
32023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32025 if (!SWIG_IsOK(res1)) {
32026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32027 }
32028 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32029 ecode2 = SWIG_AsVal_int(obj1, &val2);
32030 if (!SWIG_IsOK(ecode2)) {
32031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32032 }
32033 arg2 = static_cast< int >(val2);
32034 ecode3 = SWIG_AsVal_int(obj2, &val3);
32035 if (!SWIG_IsOK(ecode3)) {
32036 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32037 }
32038 arg3 = static_cast< int >(val3);
32039 ecode4 = SWIG_AsVal_int(obj3, &val4);
32040 if (!SWIG_IsOK(ecode4)) {
32041 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32042 }
32043 arg4 = static_cast< int >(val4);
32044 {
32045 PyThreadState* __tstate = wxPyBeginAllowThreads();
32046 (arg1)->Set(arg2,arg3,arg4);
32047 wxPyEndAllowThreads(__tstate);
32048 if (PyErr_Occurred()) SWIG_fail;
32049 }
32050 resultobj = SWIG_Py_Void();
32051 return resultobj;
32052 fail:
32053 return NULL;
32054 }
32055
32056
32057 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32058 PyObject *resultobj = 0;
32059 wxString *arg1 = 0 ;
32060 wxAcceleratorEntry *result = 0 ;
32061 bool temp1 = false ;
32062 PyObject * obj0 = 0 ;
32063 char * kwnames[] = {
32064 (char *) "str", NULL
32065 };
32066
32067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32068 {
32069 arg1 = wxString_in_helper(obj0);
32070 if (arg1 == NULL) SWIG_fail;
32071 temp1 = true;
32072 }
32073 {
32074 PyThreadState* __tstate = wxPyBeginAllowThreads();
32075 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32076 wxPyEndAllowThreads(__tstate);
32077 if (PyErr_Occurred()) SWIG_fail;
32078 }
32079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32080 {
32081 if (temp1)
32082 delete arg1;
32083 }
32084 return resultobj;
32085 fail:
32086 {
32087 if (temp1)
32088 delete arg1;
32089 }
32090 return NULL;
32091 }
32092
32093
32094 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32095 PyObject *resultobj = 0;
32096 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32097 int result;
32098 void *argp1 = 0 ;
32099 int res1 = 0 ;
32100 PyObject *swig_obj[1] ;
32101
32102 if (!args) SWIG_fail;
32103 swig_obj[0] = args;
32104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32105 if (!SWIG_IsOK(res1)) {
32106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32107 }
32108 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32109 {
32110 PyThreadState* __tstate = wxPyBeginAllowThreads();
32111 result = (int)(arg1)->GetFlags();
32112 wxPyEndAllowThreads(__tstate);
32113 if (PyErr_Occurred()) SWIG_fail;
32114 }
32115 resultobj = SWIG_From_int(static_cast< int >(result));
32116 return resultobj;
32117 fail:
32118 return NULL;
32119 }
32120
32121
32122 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32123 PyObject *resultobj = 0;
32124 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32125 int result;
32126 void *argp1 = 0 ;
32127 int res1 = 0 ;
32128 PyObject *swig_obj[1] ;
32129
32130 if (!args) SWIG_fail;
32131 swig_obj[0] = args;
32132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32133 if (!SWIG_IsOK(res1)) {
32134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32135 }
32136 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32137 {
32138 PyThreadState* __tstate = wxPyBeginAllowThreads();
32139 result = (int)(arg1)->GetKeyCode();
32140 wxPyEndAllowThreads(__tstate);
32141 if (PyErr_Occurred()) SWIG_fail;
32142 }
32143 resultobj = SWIG_From_int(static_cast< int >(result));
32144 return resultobj;
32145 fail:
32146 return NULL;
32147 }
32148
32149
32150 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32151 PyObject *resultobj = 0;
32152 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32153 int result;
32154 void *argp1 = 0 ;
32155 int res1 = 0 ;
32156 PyObject *swig_obj[1] ;
32157
32158 if (!args) SWIG_fail;
32159 swig_obj[0] = args;
32160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32161 if (!SWIG_IsOK(res1)) {
32162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32163 }
32164 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32165 {
32166 PyThreadState* __tstate = wxPyBeginAllowThreads();
32167 result = (int)(arg1)->GetCommand();
32168 wxPyEndAllowThreads(__tstate);
32169 if (PyErr_Occurred()) SWIG_fail;
32170 }
32171 resultobj = SWIG_From_int(static_cast< int >(result));
32172 return resultobj;
32173 fail:
32174 return NULL;
32175 }
32176
32177
32178 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32179 PyObject *resultobj = 0;
32180 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32181 bool result;
32182 void *argp1 = 0 ;
32183 int res1 = 0 ;
32184 PyObject *swig_obj[1] ;
32185
32186 if (!args) SWIG_fail;
32187 swig_obj[0] = args;
32188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32189 if (!SWIG_IsOK(res1)) {
32190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32191 }
32192 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32193 {
32194 PyThreadState* __tstate = wxPyBeginAllowThreads();
32195 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32196 wxPyEndAllowThreads(__tstate);
32197 if (PyErr_Occurred()) SWIG_fail;
32198 }
32199 {
32200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32201 }
32202 return resultobj;
32203 fail:
32204 return NULL;
32205 }
32206
32207
32208 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32209 PyObject *resultobj = 0;
32210 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32211 wxString result;
32212 void *argp1 = 0 ;
32213 int res1 = 0 ;
32214 PyObject *swig_obj[1] ;
32215
32216 if (!args) SWIG_fail;
32217 swig_obj[0] = args;
32218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32219 if (!SWIG_IsOK(res1)) {
32220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32221 }
32222 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32223 {
32224 PyThreadState* __tstate = wxPyBeginAllowThreads();
32225 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32226 wxPyEndAllowThreads(__tstate);
32227 if (PyErr_Occurred()) SWIG_fail;
32228 }
32229 {
32230 #if wxUSE_UNICODE
32231 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32232 #else
32233 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32234 #endif
32235 }
32236 return resultobj;
32237 fail:
32238 return NULL;
32239 }
32240
32241
32242 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32243 PyObject *resultobj = 0;
32244 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32245 wxString *arg2 = 0 ;
32246 bool result;
32247 void *argp1 = 0 ;
32248 int res1 = 0 ;
32249 bool temp2 = false ;
32250 PyObject * obj0 = 0 ;
32251 PyObject * obj1 = 0 ;
32252 char * kwnames[] = {
32253 (char *) "self",(char *) "str", NULL
32254 };
32255
32256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32258 if (!SWIG_IsOK(res1)) {
32259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32260 }
32261 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32262 {
32263 arg2 = wxString_in_helper(obj1);
32264 if (arg2 == NULL) SWIG_fail;
32265 temp2 = true;
32266 }
32267 {
32268 PyThreadState* __tstate = wxPyBeginAllowThreads();
32269 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32270 wxPyEndAllowThreads(__tstate);
32271 if (PyErr_Occurred()) SWIG_fail;
32272 }
32273 {
32274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32275 }
32276 {
32277 if (temp2)
32278 delete arg2;
32279 }
32280 return resultobj;
32281 fail:
32282 {
32283 if (temp2)
32284 delete arg2;
32285 }
32286 return NULL;
32287 }
32288
32289
32290 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32291 PyObject *obj;
32292 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32293 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32294 return SWIG_Py_Void();
32295 }
32296
32297 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32298 return SWIG_Python_InitShadowInstance(args);
32299 }
32300
32301 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32302 PyObject *resultobj = 0;
32303 int arg1 ;
32304 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32305 wxAcceleratorTable *result = 0 ;
32306 PyObject * obj0 = 0 ;
32307 char * kwnames[] = {
32308 (char *) "n", NULL
32309 };
32310
32311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32312 {
32313 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32314 if (arg2) arg1 = PyList_Size(obj0);
32315 else arg1 = 0;
32316 }
32317 {
32318 PyThreadState* __tstate = wxPyBeginAllowThreads();
32319 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32320 wxPyEndAllowThreads(__tstate);
32321 if (PyErr_Occurred()) SWIG_fail;
32322 }
32323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32324 return resultobj;
32325 fail:
32326 return NULL;
32327 }
32328
32329
32330 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32331 PyObject *resultobj = 0;
32332 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32333 void *argp1 = 0 ;
32334 int res1 = 0 ;
32335 PyObject *swig_obj[1] ;
32336
32337 if (!args) SWIG_fail;
32338 swig_obj[0] = args;
32339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32340 if (!SWIG_IsOK(res1)) {
32341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32342 }
32343 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32344 {
32345 PyThreadState* __tstate = wxPyBeginAllowThreads();
32346 delete arg1;
32347
32348 wxPyEndAllowThreads(__tstate);
32349 if (PyErr_Occurred()) SWIG_fail;
32350 }
32351 resultobj = SWIG_Py_Void();
32352 return resultobj;
32353 fail:
32354 return NULL;
32355 }
32356
32357
32358 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32359 PyObject *resultobj = 0;
32360 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32361 bool result;
32362 void *argp1 = 0 ;
32363 int res1 = 0 ;
32364 PyObject *swig_obj[1] ;
32365
32366 if (!args) SWIG_fail;
32367 swig_obj[0] = args;
32368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32369 if (!SWIG_IsOK(res1)) {
32370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32371 }
32372 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32373 {
32374 PyThreadState* __tstate = wxPyBeginAllowThreads();
32375 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32376 wxPyEndAllowThreads(__tstate);
32377 if (PyErr_Occurred()) SWIG_fail;
32378 }
32379 {
32380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32381 }
32382 return resultobj;
32383 fail:
32384 return NULL;
32385 }
32386
32387
32388 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32389 PyObject *obj;
32390 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32391 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32392 return SWIG_Py_Void();
32393 }
32394
32395 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32396 return SWIG_Python_InitShadowInstance(args);
32397 }
32398
32399 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32400 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32401 return 1;
32402 }
32403
32404
32405 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32406 PyObject *pyobj = 0;
32407
32408 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32409 return pyobj;
32410 }
32411
32412
32413 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32414 PyObject *resultobj = 0;
32415 wxString *arg1 = 0 ;
32416 wxAcceleratorEntry *result = 0 ;
32417 bool temp1 = false ;
32418 PyObject * obj0 = 0 ;
32419 char * kwnames[] = {
32420 (char *) "label", NULL
32421 };
32422
32423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
32424 {
32425 arg1 = wxString_in_helper(obj0);
32426 if (arg1 == NULL) SWIG_fail;
32427 temp1 = true;
32428 }
32429 {
32430 PyThreadState* __tstate = wxPyBeginAllowThreads();
32431 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
32432 wxPyEndAllowThreads(__tstate);
32433 if (PyErr_Occurred()) SWIG_fail;
32434 }
32435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32436 {
32437 if (temp1)
32438 delete arg1;
32439 }
32440 return resultobj;
32441 fail:
32442 {
32443 if (temp1)
32444 delete arg1;
32445 }
32446 return NULL;
32447 }
32448
32449
32450 SWIGINTERN int PanelNameStr_set(PyObject *) {
32451 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32452 return 1;
32453 }
32454
32455
32456 SWIGINTERN PyObject *PanelNameStr_get(void) {
32457 PyObject *pyobj = 0;
32458
32459 {
32460 #if wxUSE_UNICODE
32461 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32462 #else
32463 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32464 #endif
32465 }
32466 return pyobj;
32467 }
32468
32469
32470 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32471 PyObject *resultobj = 0;
32472 wxVisualAttributes *result = 0 ;
32473
32474 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32475 {
32476 PyThreadState* __tstate = wxPyBeginAllowThreads();
32477 result = (wxVisualAttributes *)new_wxVisualAttributes();
32478 wxPyEndAllowThreads(__tstate);
32479 if (PyErr_Occurred()) SWIG_fail;
32480 }
32481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32482 return resultobj;
32483 fail:
32484 return NULL;
32485 }
32486
32487
32488 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32489 PyObject *resultobj = 0;
32490 wxVisualAttributes *arg1 = (wxVisualAttributes *) 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_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32498 if (!SWIG_IsOK(res1)) {
32499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32500 }
32501 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32502 {
32503 PyThreadState* __tstate = wxPyBeginAllowThreads();
32504 delete_wxVisualAttributes(arg1);
32505
32506 wxPyEndAllowThreads(__tstate);
32507 if (PyErr_Occurred()) SWIG_fail;
32508 }
32509 resultobj = SWIG_Py_Void();
32510 return resultobj;
32511 fail:
32512 return NULL;
32513 }
32514
32515
32516 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32517 PyObject *resultobj = 0;
32518 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32519 wxFont *arg2 = (wxFont *) 0 ;
32520 void *argp1 = 0 ;
32521 int res1 = 0 ;
32522 void *argp2 = 0 ;
32523 int res2 = 0 ;
32524 PyObject *swig_obj[2] ;
32525
32526 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32528 if (!SWIG_IsOK(res1)) {
32529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32530 }
32531 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32532 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32533 if (!SWIG_IsOK(res2)) {
32534 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32535 }
32536 arg2 = reinterpret_cast< wxFont * >(argp2);
32537 if (arg1) (arg1)->font = *arg2;
32538
32539 resultobj = SWIG_Py_Void();
32540 return resultobj;
32541 fail:
32542 return NULL;
32543 }
32544
32545
32546 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32547 PyObject *resultobj = 0;
32548 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32549 wxFont *result = 0 ;
32550 void *argp1 = 0 ;
32551 int res1 = 0 ;
32552 PyObject *swig_obj[1] ;
32553
32554 if (!args) SWIG_fail;
32555 swig_obj[0] = args;
32556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32557 if (!SWIG_IsOK(res1)) {
32558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32559 }
32560 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32561 result = (wxFont *)& ((arg1)->font);
32562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32563 return resultobj;
32564 fail:
32565 return NULL;
32566 }
32567
32568
32569 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32570 PyObject *resultobj = 0;
32571 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32572 wxColour *arg2 = (wxColour *) 0 ;
32573 void *argp1 = 0 ;
32574 int res1 = 0 ;
32575 void *argp2 = 0 ;
32576 int res2 = 0 ;
32577 PyObject *swig_obj[2] ;
32578
32579 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32581 if (!SWIG_IsOK(res1)) {
32582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32583 }
32584 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32585 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32586 if (!SWIG_IsOK(res2)) {
32587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32588 }
32589 arg2 = reinterpret_cast< wxColour * >(argp2);
32590 if (arg1) (arg1)->colFg = *arg2;
32591
32592 resultobj = SWIG_Py_Void();
32593 return resultobj;
32594 fail:
32595 return NULL;
32596 }
32597
32598
32599 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32600 PyObject *resultobj = 0;
32601 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32602 wxColour *result = 0 ;
32603 void *argp1 = 0 ;
32604 int res1 = 0 ;
32605 PyObject *swig_obj[1] ;
32606
32607 if (!args) SWIG_fail;
32608 swig_obj[0] = args;
32609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32610 if (!SWIG_IsOK(res1)) {
32611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32612 }
32613 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32614 result = (wxColour *)& ((arg1)->colFg);
32615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32616 return resultobj;
32617 fail:
32618 return NULL;
32619 }
32620
32621
32622 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32623 PyObject *resultobj = 0;
32624 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32625 wxColour *arg2 = (wxColour *) 0 ;
32626 void *argp1 = 0 ;
32627 int res1 = 0 ;
32628 void *argp2 = 0 ;
32629 int res2 = 0 ;
32630 PyObject *swig_obj[2] ;
32631
32632 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32634 if (!SWIG_IsOK(res1)) {
32635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32636 }
32637 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32638 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32639 if (!SWIG_IsOK(res2)) {
32640 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32641 }
32642 arg2 = reinterpret_cast< wxColour * >(argp2);
32643 if (arg1) (arg1)->colBg = *arg2;
32644
32645 resultobj = SWIG_Py_Void();
32646 return resultobj;
32647 fail:
32648 return NULL;
32649 }
32650
32651
32652 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32653 PyObject *resultobj = 0;
32654 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32655 wxColour *result = 0 ;
32656 void *argp1 = 0 ;
32657 int res1 = 0 ;
32658 PyObject *swig_obj[1] ;
32659
32660 if (!args) SWIG_fail;
32661 swig_obj[0] = args;
32662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32663 if (!SWIG_IsOK(res1)) {
32664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32665 }
32666 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32667 result = (wxColour *)& ((arg1)->colBg);
32668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32669 return resultobj;
32670 fail:
32671 return NULL;
32672 }
32673
32674
32675 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32676 PyObject *obj;
32677 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32678 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32679 return SWIG_Py_Void();
32680 }
32681
32682 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32683 return SWIG_Python_InitShadowInstance(args);
32684 }
32685
32686 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32687 PyObject *resultobj = 0;
32688 wxWindow *arg1 = (wxWindow *) 0 ;
32689 int arg2 = (int) (int)-1 ;
32690 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32691 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32692 wxSize const &arg4_defvalue = wxDefaultSize ;
32693 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32694 long arg5 = (long) 0 ;
32695 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32696 wxString *arg6 = (wxString *) &arg6_defvalue ;
32697 wxWindow *result = 0 ;
32698 void *argp1 = 0 ;
32699 int res1 = 0 ;
32700 int val2 ;
32701 int ecode2 = 0 ;
32702 wxPoint temp3 ;
32703 wxSize temp4 ;
32704 long val5 ;
32705 int ecode5 = 0 ;
32706 bool temp6 = false ;
32707 PyObject * obj0 = 0 ;
32708 PyObject * obj1 = 0 ;
32709 PyObject * obj2 = 0 ;
32710 PyObject * obj3 = 0 ;
32711 PyObject * obj4 = 0 ;
32712 PyObject * obj5 = 0 ;
32713 char * kwnames[] = {
32714 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32715 };
32716
32717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32719 if (!SWIG_IsOK(res1)) {
32720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32721 }
32722 arg1 = reinterpret_cast< wxWindow * >(argp1);
32723 if (obj1) {
32724 ecode2 = SWIG_AsVal_int(obj1, &val2);
32725 if (!SWIG_IsOK(ecode2)) {
32726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32727 }
32728 arg2 = static_cast< int >(val2);
32729 }
32730 if (obj2) {
32731 {
32732 arg3 = &temp3;
32733 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32734 }
32735 }
32736 if (obj3) {
32737 {
32738 arg4 = &temp4;
32739 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32740 }
32741 }
32742 if (obj4) {
32743 ecode5 = SWIG_AsVal_long(obj4, &val5);
32744 if (!SWIG_IsOK(ecode5)) {
32745 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32746 }
32747 arg5 = static_cast< long >(val5);
32748 }
32749 if (obj5) {
32750 {
32751 arg6 = wxString_in_helper(obj5);
32752 if (arg6 == NULL) SWIG_fail;
32753 temp6 = true;
32754 }
32755 }
32756 {
32757 if (!wxPyCheckForApp()) SWIG_fail;
32758 PyThreadState* __tstate = wxPyBeginAllowThreads();
32759 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32760 wxPyEndAllowThreads(__tstate);
32761 if (PyErr_Occurred()) SWIG_fail;
32762 }
32763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32764 {
32765 if (temp6)
32766 delete arg6;
32767 }
32768 return resultobj;
32769 fail:
32770 {
32771 if (temp6)
32772 delete arg6;
32773 }
32774 return NULL;
32775 }
32776
32777
32778 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32779 PyObject *resultobj = 0;
32780 wxWindow *result = 0 ;
32781
32782 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32783 {
32784 if (!wxPyCheckForApp()) SWIG_fail;
32785 PyThreadState* __tstate = wxPyBeginAllowThreads();
32786 result = (wxWindow *)new wxWindow();
32787 wxPyEndAllowThreads(__tstate);
32788 if (PyErr_Occurred()) SWIG_fail;
32789 }
32790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32791 return resultobj;
32792 fail:
32793 return NULL;
32794 }
32795
32796
32797 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32798 PyObject *resultobj = 0;
32799 wxWindow *arg1 = (wxWindow *) 0 ;
32800 wxWindow *arg2 = (wxWindow *) 0 ;
32801 int arg3 = (int) (int)-1 ;
32802 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32803 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32804 wxSize const &arg5_defvalue = wxDefaultSize ;
32805 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32806 long arg6 = (long) 0 ;
32807 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32808 wxString *arg7 = (wxString *) &arg7_defvalue ;
32809 bool result;
32810 void *argp1 = 0 ;
32811 int res1 = 0 ;
32812 void *argp2 = 0 ;
32813 int res2 = 0 ;
32814 int val3 ;
32815 int ecode3 = 0 ;
32816 wxPoint temp4 ;
32817 wxSize temp5 ;
32818 long val6 ;
32819 int ecode6 = 0 ;
32820 bool temp7 = false ;
32821 PyObject * obj0 = 0 ;
32822 PyObject * obj1 = 0 ;
32823 PyObject * obj2 = 0 ;
32824 PyObject * obj3 = 0 ;
32825 PyObject * obj4 = 0 ;
32826 PyObject * obj5 = 0 ;
32827 PyObject * obj6 = 0 ;
32828 char * kwnames[] = {
32829 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32830 };
32831
32832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32834 if (!SWIG_IsOK(res1)) {
32835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
32836 }
32837 arg1 = reinterpret_cast< wxWindow * >(argp1);
32838 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32839 if (!SWIG_IsOK(res2)) {
32840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
32841 }
32842 arg2 = reinterpret_cast< wxWindow * >(argp2);
32843 if (obj2) {
32844 ecode3 = SWIG_AsVal_int(obj2, &val3);
32845 if (!SWIG_IsOK(ecode3)) {
32846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
32847 }
32848 arg3 = static_cast< int >(val3);
32849 }
32850 if (obj3) {
32851 {
32852 arg4 = &temp4;
32853 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32854 }
32855 }
32856 if (obj4) {
32857 {
32858 arg5 = &temp5;
32859 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
32860 }
32861 }
32862 if (obj5) {
32863 ecode6 = SWIG_AsVal_long(obj5, &val6);
32864 if (!SWIG_IsOK(ecode6)) {
32865 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
32866 }
32867 arg6 = static_cast< long >(val6);
32868 }
32869 if (obj6) {
32870 {
32871 arg7 = wxString_in_helper(obj6);
32872 if (arg7 == NULL) SWIG_fail;
32873 temp7 = true;
32874 }
32875 }
32876 {
32877 PyThreadState* __tstate = wxPyBeginAllowThreads();
32878 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
32879 wxPyEndAllowThreads(__tstate);
32880 if (PyErr_Occurred()) SWIG_fail;
32881 }
32882 {
32883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32884 }
32885 {
32886 if (temp7)
32887 delete arg7;
32888 }
32889 return resultobj;
32890 fail:
32891 {
32892 if (temp7)
32893 delete arg7;
32894 }
32895 return NULL;
32896 }
32897
32898
32899 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32900 PyObject *resultobj = 0;
32901 wxWindow *arg1 = (wxWindow *) 0 ;
32902 bool arg2 = (bool) false ;
32903 bool result;
32904 void *argp1 = 0 ;
32905 int res1 = 0 ;
32906 bool val2 ;
32907 int ecode2 = 0 ;
32908 PyObject * obj0 = 0 ;
32909 PyObject * obj1 = 0 ;
32910 char * kwnames[] = {
32911 (char *) "self",(char *) "force", NULL
32912 };
32913
32914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
32915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32916 if (!SWIG_IsOK(res1)) {
32917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
32918 }
32919 arg1 = reinterpret_cast< wxWindow * >(argp1);
32920 if (obj1) {
32921 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32922 if (!SWIG_IsOK(ecode2)) {
32923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
32924 }
32925 arg2 = static_cast< bool >(val2);
32926 }
32927 {
32928 PyThreadState* __tstate = wxPyBeginAllowThreads();
32929 result = (bool)(arg1)->Close(arg2);
32930 wxPyEndAllowThreads(__tstate);
32931 if (PyErr_Occurred()) SWIG_fail;
32932 }
32933 {
32934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32935 }
32936 return resultobj;
32937 fail:
32938 return NULL;
32939 }
32940
32941
32942 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32943 PyObject *resultobj = 0;
32944 wxWindow *arg1 = (wxWindow *) 0 ;
32945 bool result;
32946 void *argp1 = 0 ;
32947 int res1 = 0 ;
32948 PyObject *swig_obj[1] ;
32949
32950 if (!args) SWIG_fail;
32951 swig_obj[0] = args;
32952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32953 if (!SWIG_IsOK(res1)) {
32954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
32955 }
32956 arg1 = reinterpret_cast< wxWindow * >(argp1);
32957 {
32958 PyThreadState* __tstate = wxPyBeginAllowThreads();
32959 result = (bool)(arg1)->Destroy();
32960 wxPyEndAllowThreads(__tstate);
32961 if (PyErr_Occurred()) SWIG_fail;
32962 }
32963 {
32964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32965 }
32966 return resultobj;
32967 fail:
32968 return NULL;
32969 }
32970
32971
32972 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32973 PyObject *resultobj = 0;
32974 wxWindow *arg1 = (wxWindow *) 0 ;
32975 bool result;
32976 void *argp1 = 0 ;
32977 int res1 = 0 ;
32978 PyObject *swig_obj[1] ;
32979
32980 if (!args) SWIG_fail;
32981 swig_obj[0] = args;
32982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32983 if (!SWIG_IsOK(res1)) {
32984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32985 }
32986 arg1 = reinterpret_cast< wxWindow * >(argp1);
32987 {
32988 PyThreadState* __tstate = wxPyBeginAllowThreads();
32989 result = (bool)(arg1)->DestroyChildren();
32990 wxPyEndAllowThreads(__tstate);
32991 if (PyErr_Occurred()) SWIG_fail;
32992 }
32993 {
32994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32995 }
32996 return resultobj;
32997 fail:
32998 return NULL;
32999 }
33000
33001
33002 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33003 PyObject *resultobj = 0;
33004 wxWindow *arg1 = (wxWindow *) 0 ;
33005 bool result;
33006 void *argp1 = 0 ;
33007 int res1 = 0 ;
33008 PyObject *swig_obj[1] ;
33009
33010 if (!args) SWIG_fail;
33011 swig_obj[0] = args;
33012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33013 if (!SWIG_IsOK(res1)) {
33014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33015 }
33016 arg1 = reinterpret_cast< wxWindow * >(argp1);
33017 {
33018 PyThreadState* __tstate = wxPyBeginAllowThreads();
33019 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33020 wxPyEndAllowThreads(__tstate);
33021 if (PyErr_Occurred()) SWIG_fail;
33022 }
33023 {
33024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33025 }
33026 return resultobj;
33027 fail:
33028 return NULL;
33029 }
33030
33031
33032 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33033 PyObject *resultobj = 0;
33034 wxWindow *arg1 = (wxWindow *) 0 ;
33035 wxString *arg2 = 0 ;
33036 void *argp1 = 0 ;
33037 int res1 = 0 ;
33038 bool temp2 = false ;
33039 PyObject * obj0 = 0 ;
33040 PyObject * obj1 = 0 ;
33041 char * kwnames[] = {
33042 (char *) "self",(char *) "label", NULL
33043 };
33044
33045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33047 if (!SWIG_IsOK(res1)) {
33048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33049 }
33050 arg1 = reinterpret_cast< wxWindow * >(argp1);
33051 {
33052 arg2 = wxString_in_helper(obj1);
33053 if (arg2 == NULL) SWIG_fail;
33054 temp2 = true;
33055 }
33056 {
33057 PyThreadState* __tstate = wxPyBeginAllowThreads();
33058 (arg1)->SetLabel((wxString const &)*arg2);
33059 wxPyEndAllowThreads(__tstate);
33060 if (PyErr_Occurred()) SWIG_fail;
33061 }
33062 resultobj = SWIG_Py_Void();
33063 {
33064 if (temp2)
33065 delete arg2;
33066 }
33067 return resultobj;
33068 fail:
33069 {
33070 if (temp2)
33071 delete arg2;
33072 }
33073 return NULL;
33074 }
33075
33076
33077 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33078 PyObject *resultobj = 0;
33079 wxWindow *arg1 = (wxWindow *) 0 ;
33080 wxString result;
33081 void *argp1 = 0 ;
33082 int res1 = 0 ;
33083 PyObject *swig_obj[1] ;
33084
33085 if (!args) SWIG_fail;
33086 swig_obj[0] = args;
33087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33088 if (!SWIG_IsOK(res1)) {
33089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33090 }
33091 arg1 = reinterpret_cast< wxWindow * >(argp1);
33092 {
33093 PyThreadState* __tstate = wxPyBeginAllowThreads();
33094 result = ((wxWindow const *)arg1)->GetLabel();
33095 wxPyEndAllowThreads(__tstate);
33096 if (PyErr_Occurred()) SWIG_fail;
33097 }
33098 {
33099 #if wxUSE_UNICODE
33100 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33101 #else
33102 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33103 #endif
33104 }
33105 return resultobj;
33106 fail:
33107 return NULL;
33108 }
33109
33110
33111 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33112 PyObject *resultobj = 0;
33113 wxWindow *arg1 = (wxWindow *) 0 ;
33114 wxString *arg2 = 0 ;
33115 void *argp1 = 0 ;
33116 int res1 = 0 ;
33117 bool temp2 = false ;
33118 PyObject * obj0 = 0 ;
33119 PyObject * obj1 = 0 ;
33120 char * kwnames[] = {
33121 (char *) "self",(char *) "name", NULL
33122 };
33123
33124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33126 if (!SWIG_IsOK(res1)) {
33127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33128 }
33129 arg1 = reinterpret_cast< wxWindow * >(argp1);
33130 {
33131 arg2 = wxString_in_helper(obj1);
33132 if (arg2 == NULL) SWIG_fail;
33133 temp2 = true;
33134 }
33135 {
33136 PyThreadState* __tstate = wxPyBeginAllowThreads();
33137 (arg1)->SetName((wxString const &)*arg2);
33138 wxPyEndAllowThreads(__tstate);
33139 if (PyErr_Occurred()) SWIG_fail;
33140 }
33141 resultobj = SWIG_Py_Void();
33142 {
33143 if (temp2)
33144 delete arg2;
33145 }
33146 return resultobj;
33147 fail:
33148 {
33149 if (temp2)
33150 delete arg2;
33151 }
33152 return NULL;
33153 }
33154
33155
33156 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33157 PyObject *resultobj = 0;
33158 wxWindow *arg1 = (wxWindow *) 0 ;
33159 wxString result;
33160 void *argp1 = 0 ;
33161 int res1 = 0 ;
33162 PyObject *swig_obj[1] ;
33163
33164 if (!args) SWIG_fail;
33165 swig_obj[0] = args;
33166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33167 if (!SWIG_IsOK(res1)) {
33168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33169 }
33170 arg1 = reinterpret_cast< wxWindow * >(argp1);
33171 {
33172 PyThreadState* __tstate = wxPyBeginAllowThreads();
33173 result = ((wxWindow const *)arg1)->GetName();
33174 wxPyEndAllowThreads(__tstate);
33175 if (PyErr_Occurred()) SWIG_fail;
33176 }
33177 {
33178 #if wxUSE_UNICODE
33179 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33180 #else
33181 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33182 #endif
33183 }
33184 return resultobj;
33185 fail:
33186 return NULL;
33187 }
33188
33189
33190 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33191 PyObject *resultobj = 0;
33192 wxWindow *arg1 = (wxWindow *) 0 ;
33193 wxWindowVariant arg2 ;
33194 void *argp1 = 0 ;
33195 int res1 = 0 ;
33196 int val2 ;
33197 int ecode2 = 0 ;
33198 PyObject * obj0 = 0 ;
33199 PyObject * obj1 = 0 ;
33200 char * kwnames[] = {
33201 (char *) "self",(char *) "variant", NULL
33202 };
33203
33204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33206 if (!SWIG_IsOK(res1)) {
33207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33208 }
33209 arg1 = reinterpret_cast< wxWindow * >(argp1);
33210 ecode2 = SWIG_AsVal_int(obj1, &val2);
33211 if (!SWIG_IsOK(ecode2)) {
33212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33213 }
33214 arg2 = static_cast< wxWindowVariant >(val2);
33215 {
33216 PyThreadState* __tstate = wxPyBeginAllowThreads();
33217 (arg1)->SetWindowVariant(arg2);
33218 wxPyEndAllowThreads(__tstate);
33219 if (PyErr_Occurred()) SWIG_fail;
33220 }
33221 resultobj = SWIG_Py_Void();
33222 return resultobj;
33223 fail:
33224 return NULL;
33225 }
33226
33227
33228 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33229 PyObject *resultobj = 0;
33230 wxWindow *arg1 = (wxWindow *) 0 ;
33231 wxWindowVariant result;
33232 void *argp1 = 0 ;
33233 int res1 = 0 ;
33234 PyObject *swig_obj[1] ;
33235
33236 if (!args) SWIG_fail;
33237 swig_obj[0] = args;
33238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33239 if (!SWIG_IsOK(res1)) {
33240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33241 }
33242 arg1 = reinterpret_cast< wxWindow * >(argp1);
33243 {
33244 PyThreadState* __tstate = wxPyBeginAllowThreads();
33245 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33246 wxPyEndAllowThreads(__tstate);
33247 if (PyErr_Occurred()) SWIG_fail;
33248 }
33249 resultobj = SWIG_From_int(static_cast< int >(result));
33250 return resultobj;
33251 fail:
33252 return NULL;
33253 }
33254
33255
33256 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33257 PyObject *resultobj = 0;
33258 wxWindow *arg1 = (wxWindow *) 0 ;
33259 int arg2 ;
33260 void *argp1 = 0 ;
33261 int res1 = 0 ;
33262 int val2 ;
33263 int ecode2 = 0 ;
33264 PyObject * obj0 = 0 ;
33265 PyObject * obj1 = 0 ;
33266 char * kwnames[] = {
33267 (char *) "self",(char *) "winid", NULL
33268 };
33269
33270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33272 if (!SWIG_IsOK(res1)) {
33273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33274 }
33275 arg1 = reinterpret_cast< wxWindow * >(argp1);
33276 ecode2 = SWIG_AsVal_int(obj1, &val2);
33277 if (!SWIG_IsOK(ecode2)) {
33278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33279 }
33280 arg2 = static_cast< int >(val2);
33281 {
33282 PyThreadState* __tstate = wxPyBeginAllowThreads();
33283 (arg1)->SetId(arg2);
33284 wxPyEndAllowThreads(__tstate);
33285 if (PyErr_Occurred()) SWIG_fail;
33286 }
33287 resultobj = SWIG_Py_Void();
33288 return resultobj;
33289 fail:
33290 return NULL;
33291 }
33292
33293
33294 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33295 PyObject *resultobj = 0;
33296 wxWindow *arg1 = (wxWindow *) 0 ;
33297 int result;
33298 void *argp1 = 0 ;
33299 int res1 = 0 ;
33300 PyObject *swig_obj[1] ;
33301
33302 if (!args) SWIG_fail;
33303 swig_obj[0] = args;
33304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33305 if (!SWIG_IsOK(res1)) {
33306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33307 }
33308 arg1 = reinterpret_cast< wxWindow * >(argp1);
33309 {
33310 PyThreadState* __tstate = wxPyBeginAllowThreads();
33311 result = (int)((wxWindow const *)arg1)->GetId();
33312 wxPyEndAllowThreads(__tstate);
33313 if (PyErr_Occurred()) SWIG_fail;
33314 }
33315 resultobj = SWIG_From_int(static_cast< int >(result));
33316 return resultobj;
33317 fail:
33318 return NULL;
33319 }
33320
33321
33322 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33323 PyObject *resultobj = 0;
33324 int result;
33325
33326 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33327 {
33328 PyThreadState* __tstate = wxPyBeginAllowThreads();
33329 result = (int)wxWindow::NewControlId();
33330 wxPyEndAllowThreads(__tstate);
33331 if (PyErr_Occurred()) SWIG_fail;
33332 }
33333 resultobj = SWIG_From_int(static_cast< int >(result));
33334 return resultobj;
33335 fail:
33336 return NULL;
33337 }
33338
33339
33340 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33341 PyObject *resultobj = 0;
33342 int arg1 ;
33343 int result;
33344 int val1 ;
33345 int ecode1 = 0 ;
33346 PyObject * obj0 = 0 ;
33347 char * kwnames[] = {
33348 (char *) "winid", NULL
33349 };
33350
33351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33352 ecode1 = SWIG_AsVal_int(obj0, &val1);
33353 if (!SWIG_IsOK(ecode1)) {
33354 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33355 }
33356 arg1 = static_cast< int >(val1);
33357 {
33358 PyThreadState* __tstate = wxPyBeginAllowThreads();
33359 result = (int)wxWindow::NextControlId(arg1);
33360 wxPyEndAllowThreads(__tstate);
33361 if (PyErr_Occurred()) SWIG_fail;
33362 }
33363 resultobj = SWIG_From_int(static_cast< int >(result));
33364 return resultobj;
33365 fail:
33366 return NULL;
33367 }
33368
33369
33370 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33371 PyObject *resultobj = 0;
33372 int arg1 ;
33373 int result;
33374 int val1 ;
33375 int ecode1 = 0 ;
33376 PyObject * obj0 = 0 ;
33377 char * kwnames[] = {
33378 (char *) "winid", NULL
33379 };
33380
33381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33382 ecode1 = SWIG_AsVal_int(obj0, &val1);
33383 if (!SWIG_IsOK(ecode1)) {
33384 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33385 }
33386 arg1 = static_cast< int >(val1);
33387 {
33388 PyThreadState* __tstate = wxPyBeginAllowThreads();
33389 result = (int)wxWindow::PrevControlId(arg1);
33390 wxPyEndAllowThreads(__tstate);
33391 if (PyErr_Occurred()) SWIG_fail;
33392 }
33393 resultobj = SWIG_From_int(static_cast< int >(result));
33394 return resultobj;
33395 fail:
33396 return NULL;
33397 }
33398
33399
33400 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33401 PyObject *resultobj = 0;
33402 wxWindow *arg1 = (wxWindow *) 0 ;
33403 wxLayoutDirection result;
33404 void *argp1 = 0 ;
33405 int res1 = 0 ;
33406 PyObject *swig_obj[1] ;
33407
33408 if (!args) SWIG_fail;
33409 swig_obj[0] = args;
33410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33411 if (!SWIG_IsOK(res1)) {
33412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33413 }
33414 arg1 = reinterpret_cast< wxWindow * >(argp1);
33415 {
33416 PyThreadState* __tstate = wxPyBeginAllowThreads();
33417 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33418 wxPyEndAllowThreads(__tstate);
33419 if (PyErr_Occurred()) SWIG_fail;
33420 }
33421 resultobj = SWIG_From_int(static_cast< int >(result));
33422 return resultobj;
33423 fail:
33424 return NULL;
33425 }
33426
33427
33428 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33429 PyObject *resultobj = 0;
33430 wxWindow *arg1 = (wxWindow *) 0 ;
33431 wxLayoutDirection arg2 ;
33432 void *argp1 = 0 ;
33433 int res1 = 0 ;
33434 int val2 ;
33435 int ecode2 = 0 ;
33436 PyObject * obj0 = 0 ;
33437 PyObject * obj1 = 0 ;
33438 char * kwnames[] = {
33439 (char *) "self",(char *) "dir", NULL
33440 };
33441
33442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33444 if (!SWIG_IsOK(res1)) {
33445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33446 }
33447 arg1 = reinterpret_cast< wxWindow * >(argp1);
33448 ecode2 = SWIG_AsVal_int(obj1, &val2);
33449 if (!SWIG_IsOK(ecode2)) {
33450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33451 }
33452 arg2 = static_cast< wxLayoutDirection >(val2);
33453 {
33454 PyThreadState* __tstate = wxPyBeginAllowThreads();
33455 (arg1)->SetLayoutDirection(arg2);
33456 wxPyEndAllowThreads(__tstate);
33457 if (PyErr_Occurred()) SWIG_fail;
33458 }
33459 resultobj = SWIG_Py_Void();
33460 return resultobj;
33461 fail:
33462 return NULL;
33463 }
33464
33465
33466 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33467 PyObject *resultobj = 0;
33468 wxWindow *arg1 = (wxWindow *) 0 ;
33469 int arg2 ;
33470 int arg3 ;
33471 int arg4 ;
33472 int result;
33473 void *argp1 = 0 ;
33474 int res1 = 0 ;
33475 int val2 ;
33476 int ecode2 = 0 ;
33477 int val3 ;
33478 int ecode3 = 0 ;
33479 int val4 ;
33480 int ecode4 = 0 ;
33481 PyObject * obj0 = 0 ;
33482 PyObject * obj1 = 0 ;
33483 PyObject * obj2 = 0 ;
33484 PyObject * obj3 = 0 ;
33485 char * kwnames[] = {
33486 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33487 };
33488
33489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33491 if (!SWIG_IsOK(res1)) {
33492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33493 }
33494 arg1 = reinterpret_cast< wxWindow * >(argp1);
33495 ecode2 = SWIG_AsVal_int(obj1, &val2);
33496 if (!SWIG_IsOK(ecode2)) {
33497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33498 }
33499 arg2 = static_cast< int >(val2);
33500 ecode3 = SWIG_AsVal_int(obj2, &val3);
33501 if (!SWIG_IsOK(ecode3)) {
33502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33503 }
33504 arg3 = static_cast< int >(val3);
33505 ecode4 = SWIG_AsVal_int(obj3, &val4);
33506 if (!SWIG_IsOK(ecode4)) {
33507 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33508 }
33509 arg4 = static_cast< int >(val4);
33510 {
33511 PyThreadState* __tstate = wxPyBeginAllowThreads();
33512 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33513 wxPyEndAllowThreads(__tstate);
33514 if (PyErr_Occurred()) SWIG_fail;
33515 }
33516 resultobj = SWIG_From_int(static_cast< int >(result));
33517 return resultobj;
33518 fail:
33519 return NULL;
33520 }
33521
33522
33523 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33524 PyObject *resultobj = 0;
33525 wxWindow *arg1 = (wxWindow *) 0 ;
33526 wxSize *arg2 = 0 ;
33527 void *argp1 = 0 ;
33528 int res1 = 0 ;
33529 wxSize temp2 ;
33530 PyObject * obj0 = 0 ;
33531 PyObject * obj1 = 0 ;
33532 char * kwnames[] = {
33533 (char *) "self",(char *) "size", NULL
33534 };
33535
33536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33538 if (!SWIG_IsOK(res1)) {
33539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33540 }
33541 arg1 = reinterpret_cast< wxWindow * >(argp1);
33542 {
33543 arg2 = &temp2;
33544 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33545 }
33546 {
33547 PyThreadState* __tstate = wxPyBeginAllowThreads();
33548 (arg1)->SetSize((wxSize const &)*arg2);
33549 wxPyEndAllowThreads(__tstate);
33550 if (PyErr_Occurred()) SWIG_fail;
33551 }
33552 resultobj = SWIG_Py_Void();
33553 return resultobj;
33554 fail:
33555 return NULL;
33556 }
33557
33558
33559 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33560 PyObject *resultobj = 0;
33561 wxWindow *arg1 = (wxWindow *) 0 ;
33562 int arg2 ;
33563 int arg3 ;
33564 int arg4 ;
33565 int arg5 ;
33566 int arg6 = (int) wxSIZE_AUTO ;
33567 void *argp1 = 0 ;
33568 int res1 = 0 ;
33569 int val2 ;
33570 int ecode2 = 0 ;
33571 int val3 ;
33572 int ecode3 = 0 ;
33573 int val4 ;
33574 int ecode4 = 0 ;
33575 int val5 ;
33576 int ecode5 = 0 ;
33577 int val6 ;
33578 int ecode6 = 0 ;
33579 PyObject * obj0 = 0 ;
33580 PyObject * obj1 = 0 ;
33581 PyObject * obj2 = 0 ;
33582 PyObject * obj3 = 0 ;
33583 PyObject * obj4 = 0 ;
33584 PyObject * obj5 = 0 ;
33585 char * kwnames[] = {
33586 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33587 };
33588
33589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33591 if (!SWIG_IsOK(res1)) {
33592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33593 }
33594 arg1 = reinterpret_cast< wxWindow * >(argp1);
33595 ecode2 = SWIG_AsVal_int(obj1, &val2);
33596 if (!SWIG_IsOK(ecode2)) {
33597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33598 }
33599 arg2 = static_cast< int >(val2);
33600 ecode3 = SWIG_AsVal_int(obj2, &val3);
33601 if (!SWIG_IsOK(ecode3)) {
33602 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33603 }
33604 arg3 = static_cast< int >(val3);
33605 ecode4 = SWIG_AsVal_int(obj3, &val4);
33606 if (!SWIG_IsOK(ecode4)) {
33607 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33608 }
33609 arg4 = static_cast< int >(val4);
33610 ecode5 = SWIG_AsVal_int(obj4, &val5);
33611 if (!SWIG_IsOK(ecode5)) {
33612 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33613 }
33614 arg5 = static_cast< int >(val5);
33615 if (obj5) {
33616 ecode6 = SWIG_AsVal_int(obj5, &val6);
33617 if (!SWIG_IsOK(ecode6)) {
33618 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33619 }
33620 arg6 = static_cast< int >(val6);
33621 }
33622 {
33623 PyThreadState* __tstate = wxPyBeginAllowThreads();
33624 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33625 wxPyEndAllowThreads(__tstate);
33626 if (PyErr_Occurred()) SWIG_fail;
33627 }
33628 resultobj = SWIG_Py_Void();
33629 return resultobj;
33630 fail:
33631 return NULL;
33632 }
33633
33634
33635 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33636 PyObject *resultobj = 0;
33637 wxWindow *arg1 = (wxWindow *) 0 ;
33638 wxRect *arg2 = 0 ;
33639 int arg3 = (int) wxSIZE_AUTO ;
33640 void *argp1 = 0 ;
33641 int res1 = 0 ;
33642 wxRect temp2 ;
33643 int val3 ;
33644 int ecode3 = 0 ;
33645 PyObject * obj0 = 0 ;
33646 PyObject * obj1 = 0 ;
33647 PyObject * obj2 = 0 ;
33648 char * kwnames[] = {
33649 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33650 };
33651
33652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33654 if (!SWIG_IsOK(res1)) {
33655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33656 }
33657 arg1 = reinterpret_cast< wxWindow * >(argp1);
33658 {
33659 arg2 = &temp2;
33660 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33661 }
33662 if (obj2) {
33663 ecode3 = SWIG_AsVal_int(obj2, &val3);
33664 if (!SWIG_IsOK(ecode3)) {
33665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33666 }
33667 arg3 = static_cast< int >(val3);
33668 }
33669 {
33670 PyThreadState* __tstate = wxPyBeginAllowThreads();
33671 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33672 wxPyEndAllowThreads(__tstate);
33673 if (PyErr_Occurred()) SWIG_fail;
33674 }
33675 resultobj = SWIG_Py_Void();
33676 return resultobj;
33677 fail:
33678 return NULL;
33679 }
33680
33681
33682 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33683 PyObject *resultobj = 0;
33684 wxWindow *arg1 = (wxWindow *) 0 ;
33685 int arg2 ;
33686 int arg3 ;
33687 void *argp1 = 0 ;
33688 int res1 = 0 ;
33689 int val2 ;
33690 int ecode2 = 0 ;
33691 int val3 ;
33692 int ecode3 = 0 ;
33693 PyObject * obj0 = 0 ;
33694 PyObject * obj1 = 0 ;
33695 PyObject * obj2 = 0 ;
33696 char * kwnames[] = {
33697 (char *) "self",(char *) "width",(char *) "height", NULL
33698 };
33699
33700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33702 if (!SWIG_IsOK(res1)) {
33703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33704 }
33705 arg1 = reinterpret_cast< wxWindow * >(argp1);
33706 ecode2 = SWIG_AsVal_int(obj1, &val2);
33707 if (!SWIG_IsOK(ecode2)) {
33708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33709 }
33710 arg2 = static_cast< int >(val2);
33711 ecode3 = SWIG_AsVal_int(obj2, &val3);
33712 if (!SWIG_IsOK(ecode3)) {
33713 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33714 }
33715 arg3 = static_cast< int >(val3);
33716 {
33717 PyThreadState* __tstate = wxPyBeginAllowThreads();
33718 (arg1)->SetSize(arg2,arg3);
33719 wxPyEndAllowThreads(__tstate);
33720 if (PyErr_Occurred()) SWIG_fail;
33721 }
33722 resultobj = SWIG_Py_Void();
33723 return resultobj;
33724 fail:
33725 return NULL;
33726 }
33727
33728
33729 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33730 PyObject *resultobj = 0;
33731 wxWindow *arg1 = (wxWindow *) 0 ;
33732 wxPoint *arg2 = 0 ;
33733 int arg3 = (int) wxSIZE_USE_EXISTING ;
33734 void *argp1 = 0 ;
33735 int res1 = 0 ;
33736 wxPoint temp2 ;
33737 int val3 ;
33738 int ecode3 = 0 ;
33739 PyObject * obj0 = 0 ;
33740 PyObject * obj1 = 0 ;
33741 PyObject * obj2 = 0 ;
33742 char * kwnames[] = {
33743 (char *) "self",(char *) "pt",(char *) "flags", NULL
33744 };
33745
33746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33748 if (!SWIG_IsOK(res1)) {
33749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33750 }
33751 arg1 = reinterpret_cast< wxWindow * >(argp1);
33752 {
33753 arg2 = &temp2;
33754 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33755 }
33756 if (obj2) {
33757 ecode3 = SWIG_AsVal_int(obj2, &val3);
33758 if (!SWIG_IsOK(ecode3)) {
33759 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33760 }
33761 arg3 = static_cast< int >(val3);
33762 }
33763 {
33764 PyThreadState* __tstate = wxPyBeginAllowThreads();
33765 (arg1)->Move((wxPoint const &)*arg2,arg3);
33766 wxPyEndAllowThreads(__tstate);
33767 if (PyErr_Occurred()) SWIG_fail;
33768 }
33769 resultobj = SWIG_Py_Void();
33770 return resultobj;
33771 fail:
33772 return NULL;
33773 }
33774
33775
33776 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33777 PyObject *resultobj = 0;
33778 wxWindow *arg1 = (wxWindow *) 0 ;
33779 int arg2 ;
33780 int arg3 ;
33781 int arg4 = (int) wxSIZE_USE_EXISTING ;
33782 void *argp1 = 0 ;
33783 int res1 = 0 ;
33784 int val2 ;
33785 int ecode2 = 0 ;
33786 int val3 ;
33787 int ecode3 = 0 ;
33788 int val4 ;
33789 int ecode4 = 0 ;
33790 PyObject * obj0 = 0 ;
33791 PyObject * obj1 = 0 ;
33792 PyObject * obj2 = 0 ;
33793 PyObject * obj3 = 0 ;
33794 char * kwnames[] = {
33795 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33796 };
33797
33798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33800 if (!SWIG_IsOK(res1)) {
33801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33802 }
33803 arg1 = reinterpret_cast< wxWindow * >(argp1);
33804 ecode2 = SWIG_AsVal_int(obj1, &val2);
33805 if (!SWIG_IsOK(ecode2)) {
33806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33807 }
33808 arg2 = static_cast< int >(val2);
33809 ecode3 = SWIG_AsVal_int(obj2, &val3);
33810 if (!SWIG_IsOK(ecode3)) {
33811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33812 }
33813 arg3 = static_cast< int >(val3);
33814 if (obj3) {
33815 ecode4 = SWIG_AsVal_int(obj3, &val4);
33816 if (!SWIG_IsOK(ecode4)) {
33817 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33818 }
33819 arg4 = static_cast< int >(val4);
33820 }
33821 {
33822 PyThreadState* __tstate = wxPyBeginAllowThreads();
33823 (arg1)->Move(arg2,arg3,arg4);
33824 wxPyEndAllowThreads(__tstate);
33825 if (PyErr_Occurred()) SWIG_fail;
33826 }
33827 resultobj = SWIG_Py_Void();
33828 return resultobj;
33829 fail:
33830 return NULL;
33831 }
33832
33833
33834 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33835 PyObject *resultobj = 0;
33836 wxWindow *arg1 = (wxWindow *) 0 ;
33837 wxSize const &arg2_defvalue = wxDefaultSize ;
33838 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
33839 void *argp1 = 0 ;
33840 int res1 = 0 ;
33841 wxSize temp2 ;
33842 PyObject * obj0 = 0 ;
33843 PyObject * obj1 = 0 ;
33844 char * kwnames[] = {
33845 (char *) "self",(char *) "size", NULL
33846 };
33847
33848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
33849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33850 if (!SWIG_IsOK(res1)) {
33851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33852 }
33853 arg1 = reinterpret_cast< wxWindow * >(argp1);
33854 if (obj1) {
33855 {
33856 arg2 = &temp2;
33857 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33858 }
33859 }
33860 {
33861 PyThreadState* __tstate = wxPyBeginAllowThreads();
33862 (arg1)->SetInitialSize((wxSize const &)*arg2);
33863 wxPyEndAllowThreads(__tstate);
33864 if (PyErr_Occurred()) SWIG_fail;
33865 }
33866 resultobj = SWIG_Py_Void();
33867 return resultobj;
33868 fail:
33869 return NULL;
33870 }
33871
33872
33873 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33874 PyObject *resultobj = 0;
33875 wxWindow *arg1 = (wxWindow *) 0 ;
33876 void *argp1 = 0 ;
33877 int res1 = 0 ;
33878 PyObject *swig_obj[1] ;
33879
33880 if (!args) SWIG_fail;
33881 swig_obj[0] = args;
33882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33883 if (!SWIG_IsOK(res1)) {
33884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
33885 }
33886 arg1 = reinterpret_cast< wxWindow * >(argp1);
33887 {
33888 PyThreadState* __tstate = wxPyBeginAllowThreads();
33889 (arg1)->Raise();
33890 wxPyEndAllowThreads(__tstate);
33891 if (PyErr_Occurred()) SWIG_fail;
33892 }
33893 resultobj = SWIG_Py_Void();
33894 return resultobj;
33895 fail:
33896 return NULL;
33897 }
33898
33899
33900 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33901 PyObject *resultobj = 0;
33902 wxWindow *arg1 = (wxWindow *) 0 ;
33903 void *argp1 = 0 ;
33904 int res1 = 0 ;
33905 PyObject *swig_obj[1] ;
33906
33907 if (!args) SWIG_fail;
33908 swig_obj[0] = args;
33909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33910 if (!SWIG_IsOK(res1)) {
33911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
33912 }
33913 arg1 = reinterpret_cast< wxWindow * >(argp1);
33914 {
33915 PyThreadState* __tstate = wxPyBeginAllowThreads();
33916 (arg1)->Lower();
33917 wxPyEndAllowThreads(__tstate);
33918 if (PyErr_Occurred()) SWIG_fail;
33919 }
33920 resultobj = SWIG_Py_Void();
33921 return resultobj;
33922 fail:
33923 return NULL;
33924 }
33925
33926
33927 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33928 PyObject *resultobj = 0;
33929 wxWindow *arg1 = (wxWindow *) 0 ;
33930 wxSize *arg2 = 0 ;
33931 void *argp1 = 0 ;
33932 int res1 = 0 ;
33933 wxSize temp2 ;
33934 PyObject * obj0 = 0 ;
33935 PyObject * obj1 = 0 ;
33936 char * kwnames[] = {
33937 (char *) "self",(char *) "size", NULL
33938 };
33939
33940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
33941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33942 if (!SWIG_IsOK(res1)) {
33943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33944 }
33945 arg1 = reinterpret_cast< wxWindow * >(argp1);
33946 {
33947 arg2 = &temp2;
33948 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33949 }
33950 {
33951 PyThreadState* __tstate = wxPyBeginAllowThreads();
33952 (arg1)->SetClientSize((wxSize const &)*arg2);
33953 wxPyEndAllowThreads(__tstate);
33954 if (PyErr_Occurred()) SWIG_fail;
33955 }
33956 resultobj = SWIG_Py_Void();
33957 return resultobj;
33958 fail:
33959 return NULL;
33960 }
33961
33962
33963 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33964 PyObject *resultobj = 0;
33965 wxWindow *arg1 = (wxWindow *) 0 ;
33966 int arg2 ;
33967 int arg3 ;
33968 void *argp1 = 0 ;
33969 int res1 = 0 ;
33970 int val2 ;
33971 int ecode2 = 0 ;
33972 int val3 ;
33973 int ecode3 = 0 ;
33974 PyObject * obj0 = 0 ;
33975 PyObject * obj1 = 0 ;
33976 PyObject * obj2 = 0 ;
33977 char * kwnames[] = {
33978 (char *) "self",(char *) "width",(char *) "height", NULL
33979 };
33980
33981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33983 if (!SWIG_IsOK(res1)) {
33984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33985 }
33986 arg1 = reinterpret_cast< wxWindow * >(argp1);
33987 ecode2 = SWIG_AsVal_int(obj1, &val2);
33988 if (!SWIG_IsOK(ecode2)) {
33989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
33990 }
33991 arg2 = static_cast< int >(val2);
33992 ecode3 = SWIG_AsVal_int(obj2, &val3);
33993 if (!SWIG_IsOK(ecode3)) {
33994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
33995 }
33996 arg3 = static_cast< int >(val3);
33997 {
33998 PyThreadState* __tstate = wxPyBeginAllowThreads();
33999 (arg1)->SetClientSize(arg2,arg3);
34000 wxPyEndAllowThreads(__tstate);
34001 if (PyErr_Occurred()) SWIG_fail;
34002 }
34003 resultobj = SWIG_Py_Void();
34004 return resultobj;
34005 fail:
34006 return NULL;
34007 }
34008
34009
34010 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34011 PyObject *resultobj = 0;
34012 wxWindow *arg1 = (wxWindow *) 0 ;
34013 wxRect *arg2 = 0 ;
34014 void *argp1 = 0 ;
34015 int res1 = 0 ;
34016 wxRect temp2 ;
34017 PyObject * obj0 = 0 ;
34018 PyObject * obj1 = 0 ;
34019 char * kwnames[] = {
34020 (char *) "self",(char *) "rect", NULL
34021 };
34022
34023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34025 if (!SWIG_IsOK(res1)) {
34026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34027 }
34028 arg1 = reinterpret_cast< wxWindow * >(argp1);
34029 {
34030 arg2 = &temp2;
34031 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34032 }
34033 {
34034 PyThreadState* __tstate = wxPyBeginAllowThreads();
34035 (arg1)->SetClientSize((wxRect const &)*arg2);
34036 wxPyEndAllowThreads(__tstate);
34037 if (PyErr_Occurred()) SWIG_fail;
34038 }
34039 resultobj = SWIG_Py_Void();
34040 return resultobj;
34041 fail:
34042 return NULL;
34043 }
34044
34045
34046 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34047 PyObject *resultobj = 0;
34048 wxWindow *arg1 = (wxWindow *) 0 ;
34049 wxPoint result;
34050 void *argp1 = 0 ;
34051 int res1 = 0 ;
34052 PyObject *swig_obj[1] ;
34053
34054 if (!args) SWIG_fail;
34055 swig_obj[0] = args;
34056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34057 if (!SWIG_IsOK(res1)) {
34058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34059 }
34060 arg1 = reinterpret_cast< wxWindow * >(argp1);
34061 {
34062 PyThreadState* __tstate = wxPyBeginAllowThreads();
34063 result = ((wxWindow const *)arg1)->GetPosition();
34064 wxPyEndAllowThreads(__tstate);
34065 if (PyErr_Occurred()) SWIG_fail;
34066 }
34067 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34068 return resultobj;
34069 fail:
34070 return NULL;
34071 }
34072
34073
34074 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34075 PyObject *resultobj = 0;
34076 wxWindow *arg1 = (wxWindow *) 0 ;
34077 int *arg2 = (int *) 0 ;
34078 int *arg3 = (int *) 0 ;
34079 void *argp1 = 0 ;
34080 int res1 = 0 ;
34081 int temp2 ;
34082 int res2 = SWIG_TMPOBJ ;
34083 int temp3 ;
34084 int res3 = SWIG_TMPOBJ ;
34085 PyObject *swig_obj[1] ;
34086
34087 arg2 = &temp2;
34088 arg3 = &temp3;
34089 if (!args) SWIG_fail;
34090 swig_obj[0] = args;
34091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34092 if (!SWIG_IsOK(res1)) {
34093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34094 }
34095 arg1 = reinterpret_cast< wxWindow * >(argp1);
34096 {
34097 PyThreadState* __tstate = wxPyBeginAllowThreads();
34098 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34099 wxPyEndAllowThreads(__tstate);
34100 if (PyErr_Occurred()) SWIG_fail;
34101 }
34102 resultobj = SWIG_Py_Void();
34103 if (SWIG_IsTmpObj(res2)) {
34104 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34105 } else {
34106 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34107 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34108 }
34109 if (SWIG_IsTmpObj(res3)) {
34110 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34111 } else {
34112 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34113 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34114 }
34115 return resultobj;
34116 fail:
34117 return NULL;
34118 }
34119
34120
34121 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34122 PyObject *resultobj = 0;
34123 wxWindow *arg1 = (wxWindow *) 0 ;
34124 wxPoint result;
34125 void *argp1 = 0 ;
34126 int res1 = 0 ;
34127 PyObject *swig_obj[1] ;
34128
34129 if (!args) SWIG_fail;
34130 swig_obj[0] = args;
34131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34132 if (!SWIG_IsOK(res1)) {
34133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34134 }
34135 arg1 = reinterpret_cast< wxWindow * >(argp1);
34136 {
34137 PyThreadState* __tstate = wxPyBeginAllowThreads();
34138 result = ((wxWindow const *)arg1)->GetScreenPosition();
34139 wxPyEndAllowThreads(__tstate);
34140 if (PyErr_Occurred()) SWIG_fail;
34141 }
34142 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34143 return resultobj;
34144 fail:
34145 return NULL;
34146 }
34147
34148
34149 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34150 PyObject *resultobj = 0;
34151 wxWindow *arg1 = (wxWindow *) 0 ;
34152 int *arg2 = (int *) 0 ;
34153 int *arg3 = (int *) 0 ;
34154 void *argp1 = 0 ;
34155 int res1 = 0 ;
34156 int temp2 ;
34157 int res2 = SWIG_TMPOBJ ;
34158 int temp3 ;
34159 int res3 = SWIG_TMPOBJ ;
34160 PyObject *swig_obj[1] ;
34161
34162 arg2 = &temp2;
34163 arg3 = &temp3;
34164 if (!args) SWIG_fail;
34165 swig_obj[0] = args;
34166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34167 if (!SWIG_IsOK(res1)) {
34168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34169 }
34170 arg1 = reinterpret_cast< wxWindow * >(argp1);
34171 {
34172 PyThreadState* __tstate = wxPyBeginAllowThreads();
34173 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34174 wxPyEndAllowThreads(__tstate);
34175 if (PyErr_Occurred()) SWIG_fail;
34176 }
34177 resultobj = SWIG_Py_Void();
34178 if (SWIG_IsTmpObj(res2)) {
34179 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34180 } else {
34181 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34182 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34183 }
34184 if (SWIG_IsTmpObj(res3)) {
34185 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34186 } else {
34187 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34188 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34189 }
34190 return resultobj;
34191 fail:
34192 return NULL;
34193 }
34194
34195
34196 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34197 PyObject *resultobj = 0;
34198 wxWindow *arg1 = (wxWindow *) 0 ;
34199 wxRect result;
34200 void *argp1 = 0 ;
34201 int res1 = 0 ;
34202 PyObject *swig_obj[1] ;
34203
34204 if (!args) SWIG_fail;
34205 swig_obj[0] = args;
34206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34207 if (!SWIG_IsOK(res1)) {
34208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34209 }
34210 arg1 = reinterpret_cast< wxWindow * >(argp1);
34211 {
34212 PyThreadState* __tstate = wxPyBeginAllowThreads();
34213 result = ((wxWindow const *)arg1)->GetScreenRect();
34214 wxPyEndAllowThreads(__tstate);
34215 if (PyErr_Occurred()) SWIG_fail;
34216 }
34217 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34218 return resultobj;
34219 fail:
34220 return NULL;
34221 }
34222
34223
34224 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34225 PyObject *resultobj = 0;
34226 wxWindow *arg1 = (wxWindow *) 0 ;
34227 wxSize result;
34228 void *argp1 = 0 ;
34229 int res1 = 0 ;
34230 PyObject *swig_obj[1] ;
34231
34232 if (!args) SWIG_fail;
34233 swig_obj[0] = args;
34234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34235 if (!SWIG_IsOK(res1)) {
34236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34237 }
34238 arg1 = reinterpret_cast< wxWindow * >(argp1);
34239 {
34240 PyThreadState* __tstate = wxPyBeginAllowThreads();
34241 result = ((wxWindow const *)arg1)->GetSize();
34242 wxPyEndAllowThreads(__tstate);
34243 if (PyErr_Occurred()) SWIG_fail;
34244 }
34245 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34246 return resultobj;
34247 fail:
34248 return NULL;
34249 }
34250
34251
34252 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34253 PyObject *resultobj = 0;
34254 wxWindow *arg1 = (wxWindow *) 0 ;
34255 int *arg2 = (int *) 0 ;
34256 int *arg3 = (int *) 0 ;
34257 void *argp1 = 0 ;
34258 int res1 = 0 ;
34259 int temp2 ;
34260 int res2 = SWIG_TMPOBJ ;
34261 int temp3 ;
34262 int res3 = SWIG_TMPOBJ ;
34263 PyObject *swig_obj[1] ;
34264
34265 arg2 = &temp2;
34266 arg3 = &temp3;
34267 if (!args) SWIG_fail;
34268 swig_obj[0] = args;
34269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34270 if (!SWIG_IsOK(res1)) {
34271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34272 }
34273 arg1 = reinterpret_cast< wxWindow * >(argp1);
34274 {
34275 PyThreadState* __tstate = wxPyBeginAllowThreads();
34276 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34277 wxPyEndAllowThreads(__tstate);
34278 if (PyErr_Occurred()) SWIG_fail;
34279 }
34280 resultobj = SWIG_Py_Void();
34281 if (SWIG_IsTmpObj(res2)) {
34282 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34283 } else {
34284 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34285 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34286 }
34287 if (SWIG_IsTmpObj(res3)) {
34288 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34289 } else {
34290 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34291 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34292 }
34293 return resultobj;
34294 fail:
34295 return NULL;
34296 }
34297
34298
34299 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34300 PyObject *resultobj = 0;
34301 wxWindow *arg1 = (wxWindow *) 0 ;
34302 wxRect result;
34303 void *argp1 = 0 ;
34304 int res1 = 0 ;
34305 PyObject *swig_obj[1] ;
34306
34307 if (!args) SWIG_fail;
34308 swig_obj[0] = args;
34309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34310 if (!SWIG_IsOK(res1)) {
34311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34312 }
34313 arg1 = reinterpret_cast< wxWindow * >(argp1);
34314 {
34315 PyThreadState* __tstate = wxPyBeginAllowThreads();
34316 result = ((wxWindow const *)arg1)->GetRect();
34317 wxPyEndAllowThreads(__tstate);
34318 if (PyErr_Occurred()) SWIG_fail;
34319 }
34320 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34321 return resultobj;
34322 fail:
34323 return NULL;
34324 }
34325
34326
34327 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34328 PyObject *resultobj = 0;
34329 wxWindow *arg1 = (wxWindow *) 0 ;
34330 wxSize result;
34331 void *argp1 = 0 ;
34332 int res1 = 0 ;
34333 PyObject *swig_obj[1] ;
34334
34335 if (!args) SWIG_fail;
34336 swig_obj[0] = args;
34337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34338 if (!SWIG_IsOK(res1)) {
34339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34340 }
34341 arg1 = reinterpret_cast< wxWindow * >(argp1);
34342 {
34343 PyThreadState* __tstate = wxPyBeginAllowThreads();
34344 result = ((wxWindow const *)arg1)->GetClientSize();
34345 wxPyEndAllowThreads(__tstate);
34346 if (PyErr_Occurred()) SWIG_fail;
34347 }
34348 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34349 return resultobj;
34350 fail:
34351 return NULL;
34352 }
34353
34354
34355 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34356 PyObject *resultobj = 0;
34357 wxWindow *arg1 = (wxWindow *) 0 ;
34358 int *arg2 = (int *) 0 ;
34359 int *arg3 = (int *) 0 ;
34360 void *argp1 = 0 ;
34361 int res1 = 0 ;
34362 int temp2 ;
34363 int res2 = SWIG_TMPOBJ ;
34364 int temp3 ;
34365 int res3 = SWIG_TMPOBJ ;
34366 PyObject *swig_obj[1] ;
34367
34368 arg2 = &temp2;
34369 arg3 = &temp3;
34370 if (!args) SWIG_fail;
34371 swig_obj[0] = args;
34372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34373 if (!SWIG_IsOK(res1)) {
34374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34375 }
34376 arg1 = reinterpret_cast< wxWindow * >(argp1);
34377 {
34378 PyThreadState* __tstate = wxPyBeginAllowThreads();
34379 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34380 wxPyEndAllowThreads(__tstate);
34381 if (PyErr_Occurred()) SWIG_fail;
34382 }
34383 resultobj = SWIG_Py_Void();
34384 if (SWIG_IsTmpObj(res2)) {
34385 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34386 } else {
34387 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34388 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34389 }
34390 if (SWIG_IsTmpObj(res3)) {
34391 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34392 } else {
34393 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34394 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34395 }
34396 return resultobj;
34397 fail:
34398 return NULL;
34399 }
34400
34401
34402 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34403 PyObject *resultobj = 0;
34404 wxWindow *arg1 = (wxWindow *) 0 ;
34405 wxPoint result;
34406 void *argp1 = 0 ;
34407 int res1 = 0 ;
34408 PyObject *swig_obj[1] ;
34409
34410 if (!args) SWIG_fail;
34411 swig_obj[0] = args;
34412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34413 if (!SWIG_IsOK(res1)) {
34414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34415 }
34416 arg1 = reinterpret_cast< wxWindow * >(argp1);
34417 {
34418 PyThreadState* __tstate = wxPyBeginAllowThreads();
34419 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34420 wxPyEndAllowThreads(__tstate);
34421 if (PyErr_Occurred()) SWIG_fail;
34422 }
34423 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34424 return resultobj;
34425 fail:
34426 return NULL;
34427 }
34428
34429
34430 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34431 PyObject *resultobj = 0;
34432 wxWindow *arg1 = (wxWindow *) 0 ;
34433 wxRect result;
34434 void *argp1 = 0 ;
34435 int res1 = 0 ;
34436 PyObject *swig_obj[1] ;
34437
34438 if (!args) SWIG_fail;
34439 swig_obj[0] = args;
34440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34441 if (!SWIG_IsOK(res1)) {
34442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34443 }
34444 arg1 = reinterpret_cast< wxWindow * >(argp1);
34445 {
34446 PyThreadState* __tstate = wxPyBeginAllowThreads();
34447 result = ((wxWindow const *)arg1)->GetClientRect();
34448 wxPyEndAllowThreads(__tstate);
34449 if (PyErr_Occurred()) SWIG_fail;
34450 }
34451 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34452 return resultobj;
34453 fail:
34454 return NULL;
34455 }
34456
34457
34458 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34459 PyObject *resultobj = 0;
34460 wxWindow *arg1 = (wxWindow *) 0 ;
34461 wxSize result;
34462 void *argp1 = 0 ;
34463 int res1 = 0 ;
34464 PyObject *swig_obj[1] ;
34465
34466 if (!args) SWIG_fail;
34467 swig_obj[0] = args;
34468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34469 if (!SWIG_IsOK(res1)) {
34470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34471 }
34472 arg1 = reinterpret_cast< wxWindow * >(argp1);
34473 {
34474 PyThreadState* __tstate = wxPyBeginAllowThreads();
34475 result = ((wxWindow const *)arg1)->GetBestSize();
34476 wxPyEndAllowThreads(__tstate);
34477 if (PyErr_Occurred()) SWIG_fail;
34478 }
34479 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34480 return resultobj;
34481 fail:
34482 return NULL;
34483 }
34484
34485
34486 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34487 PyObject *resultobj = 0;
34488 wxWindow *arg1 = (wxWindow *) 0 ;
34489 int *arg2 = (int *) 0 ;
34490 int *arg3 = (int *) 0 ;
34491 void *argp1 = 0 ;
34492 int res1 = 0 ;
34493 int temp2 ;
34494 int res2 = SWIG_TMPOBJ ;
34495 int temp3 ;
34496 int res3 = SWIG_TMPOBJ ;
34497 PyObject *swig_obj[1] ;
34498
34499 arg2 = &temp2;
34500 arg3 = &temp3;
34501 if (!args) SWIG_fail;
34502 swig_obj[0] = args;
34503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34504 if (!SWIG_IsOK(res1)) {
34505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34506 }
34507 arg1 = reinterpret_cast< wxWindow * >(argp1);
34508 {
34509 PyThreadState* __tstate = wxPyBeginAllowThreads();
34510 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34511 wxPyEndAllowThreads(__tstate);
34512 if (PyErr_Occurred()) SWIG_fail;
34513 }
34514 resultobj = SWIG_Py_Void();
34515 if (SWIG_IsTmpObj(res2)) {
34516 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34517 } else {
34518 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34519 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34520 }
34521 if (SWIG_IsTmpObj(res3)) {
34522 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34523 } else {
34524 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34525 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34526 }
34527 return resultobj;
34528 fail:
34529 return NULL;
34530 }
34531
34532
34533 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34534 PyObject *resultobj = 0;
34535 wxWindow *arg1 = (wxWindow *) 0 ;
34536 void *argp1 = 0 ;
34537 int res1 = 0 ;
34538 PyObject *swig_obj[1] ;
34539
34540 if (!args) SWIG_fail;
34541 swig_obj[0] = args;
34542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34543 if (!SWIG_IsOK(res1)) {
34544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34545 }
34546 arg1 = reinterpret_cast< wxWindow * >(argp1);
34547 {
34548 PyThreadState* __tstate = wxPyBeginAllowThreads();
34549 (arg1)->InvalidateBestSize();
34550 wxPyEndAllowThreads(__tstate);
34551 if (PyErr_Occurred()) SWIG_fail;
34552 }
34553 resultobj = SWIG_Py_Void();
34554 return resultobj;
34555 fail:
34556 return NULL;
34557 }
34558
34559
34560 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34561 PyObject *resultobj = 0;
34562 wxWindow *arg1 = (wxWindow *) 0 ;
34563 wxSize *arg2 = 0 ;
34564 void *argp1 = 0 ;
34565 int res1 = 0 ;
34566 wxSize temp2 ;
34567 PyObject * obj0 = 0 ;
34568 PyObject * obj1 = 0 ;
34569 char * kwnames[] = {
34570 (char *) "self",(char *) "size", NULL
34571 };
34572
34573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34575 if (!SWIG_IsOK(res1)) {
34576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34577 }
34578 arg1 = reinterpret_cast< wxWindow * >(argp1);
34579 {
34580 arg2 = &temp2;
34581 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34582 }
34583 {
34584 PyThreadState* __tstate = wxPyBeginAllowThreads();
34585 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34586 wxPyEndAllowThreads(__tstate);
34587 if (PyErr_Occurred()) SWIG_fail;
34588 }
34589 resultobj = SWIG_Py_Void();
34590 return resultobj;
34591 fail:
34592 return NULL;
34593 }
34594
34595
34596 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34597 PyObject *resultobj = 0;
34598 wxWindow *arg1 = (wxWindow *) 0 ;
34599 wxSize result;
34600 void *argp1 = 0 ;
34601 int res1 = 0 ;
34602 PyObject *swig_obj[1] ;
34603
34604 if (!args) SWIG_fail;
34605 swig_obj[0] = args;
34606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34607 if (!SWIG_IsOK(res1)) {
34608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34609 }
34610 arg1 = reinterpret_cast< wxWindow * >(argp1);
34611 {
34612 PyThreadState* __tstate = wxPyBeginAllowThreads();
34613 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
34614 wxPyEndAllowThreads(__tstate);
34615 if (PyErr_Occurred()) SWIG_fail;
34616 }
34617 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34618 return resultobj;
34619 fail:
34620 return NULL;
34621 }
34622
34623
34624 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34625 PyObject *resultobj = 0;
34626 wxWindow *arg1 = (wxWindow *) 0 ;
34627 int arg2 = (int) wxBOTH ;
34628 void *argp1 = 0 ;
34629 int res1 = 0 ;
34630 int val2 ;
34631 int ecode2 = 0 ;
34632 PyObject * obj0 = 0 ;
34633 PyObject * obj1 = 0 ;
34634 char * kwnames[] = {
34635 (char *) "self",(char *) "direction", NULL
34636 };
34637
34638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34640 if (!SWIG_IsOK(res1)) {
34641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34642 }
34643 arg1 = reinterpret_cast< wxWindow * >(argp1);
34644 if (obj1) {
34645 ecode2 = SWIG_AsVal_int(obj1, &val2);
34646 if (!SWIG_IsOK(ecode2)) {
34647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34648 }
34649 arg2 = static_cast< int >(val2);
34650 }
34651 {
34652 PyThreadState* __tstate = wxPyBeginAllowThreads();
34653 (arg1)->Center(arg2);
34654 wxPyEndAllowThreads(__tstate);
34655 if (PyErr_Occurred()) SWIG_fail;
34656 }
34657 resultobj = SWIG_Py_Void();
34658 return resultobj;
34659 fail:
34660 return NULL;
34661 }
34662
34663
34664 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34665 PyObject *resultobj = 0;
34666 wxWindow *arg1 = (wxWindow *) 0 ;
34667 int arg2 = (int) wxBOTH ;
34668 void *argp1 = 0 ;
34669 int res1 = 0 ;
34670 int val2 ;
34671 int ecode2 = 0 ;
34672 PyObject * obj0 = 0 ;
34673 PyObject * obj1 = 0 ;
34674 char * kwnames[] = {
34675 (char *) "self",(char *) "dir", NULL
34676 };
34677
34678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34680 if (!SWIG_IsOK(res1)) {
34681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34682 }
34683 arg1 = reinterpret_cast< wxWindow * >(argp1);
34684 if (obj1) {
34685 ecode2 = SWIG_AsVal_int(obj1, &val2);
34686 if (!SWIG_IsOK(ecode2)) {
34687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34688 }
34689 arg2 = static_cast< int >(val2);
34690 }
34691 {
34692 PyThreadState* __tstate = wxPyBeginAllowThreads();
34693 (arg1)->CenterOnParent(arg2);
34694 wxPyEndAllowThreads(__tstate);
34695 if (PyErr_Occurred()) SWIG_fail;
34696 }
34697 resultobj = SWIG_Py_Void();
34698 return resultobj;
34699 fail:
34700 return NULL;
34701 }
34702
34703
34704 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34705 PyObject *resultobj = 0;
34706 wxWindow *arg1 = (wxWindow *) 0 ;
34707 void *argp1 = 0 ;
34708 int res1 = 0 ;
34709 PyObject *swig_obj[1] ;
34710
34711 if (!args) SWIG_fail;
34712 swig_obj[0] = args;
34713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34714 if (!SWIG_IsOK(res1)) {
34715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34716 }
34717 arg1 = reinterpret_cast< wxWindow * >(argp1);
34718 {
34719 PyThreadState* __tstate = wxPyBeginAllowThreads();
34720 (arg1)->Fit();
34721 wxPyEndAllowThreads(__tstate);
34722 if (PyErr_Occurred()) SWIG_fail;
34723 }
34724 resultobj = SWIG_Py_Void();
34725 return resultobj;
34726 fail:
34727 return NULL;
34728 }
34729
34730
34731 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34732 PyObject *resultobj = 0;
34733 wxWindow *arg1 = (wxWindow *) 0 ;
34734 void *argp1 = 0 ;
34735 int res1 = 0 ;
34736 PyObject *swig_obj[1] ;
34737
34738 if (!args) SWIG_fail;
34739 swig_obj[0] = args;
34740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34741 if (!SWIG_IsOK(res1)) {
34742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34743 }
34744 arg1 = reinterpret_cast< wxWindow * >(argp1);
34745 {
34746 PyThreadState* __tstate = wxPyBeginAllowThreads();
34747 (arg1)->FitInside();
34748 wxPyEndAllowThreads(__tstate);
34749 if (PyErr_Occurred()) SWIG_fail;
34750 }
34751 resultobj = SWIG_Py_Void();
34752 return resultobj;
34753 fail:
34754 return NULL;
34755 }
34756
34757
34758 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34759 PyObject *resultobj = 0;
34760 wxWindow *arg1 = (wxWindow *) 0 ;
34761 int arg2 ;
34762 int arg3 ;
34763 int arg4 = (int) -1 ;
34764 int arg5 = (int) -1 ;
34765 int arg6 = (int) -1 ;
34766 int arg7 = (int) -1 ;
34767 void *argp1 = 0 ;
34768 int res1 = 0 ;
34769 int val2 ;
34770 int ecode2 = 0 ;
34771 int val3 ;
34772 int ecode3 = 0 ;
34773 int val4 ;
34774 int ecode4 = 0 ;
34775 int val5 ;
34776 int ecode5 = 0 ;
34777 int val6 ;
34778 int ecode6 = 0 ;
34779 int val7 ;
34780 int ecode7 = 0 ;
34781 PyObject * obj0 = 0 ;
34782 PyObject * obj1 = 0 ;
34783 PyObject * obj2 = 0 ;
34784 PyObject * obj3 = 0 ;
34785 PyObject * obj4 = 0 ;
34786 PyObject * obj5 = 0 ;
34787 PyObject * obj6 = 0 ;
34788 char * kwnames[] = {
34789 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34790 };
34791
34792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34794 if (!SWIG_IsOK(res1)) {
34795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34796 }
34797 arg1 = reinterpret_cast< wxWindow * >(argp1);
34798 ecode2 = SWIG_AsVal_int(obj1, &val2);
34799 if (!SWIG_IsOK(ecode2)) {
34800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34801 }
34802 arg2 = static_cast< int >(val2);
34803 ecode3 = SWIG_AsVal_int(obj2, &val3);
34804 if (!SWIG_IsOK(ecode3)) {
34805 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34806 }
34807 arg3 = static_cast< int >(val3);
34808 if (obj3) {
34809 ecode4 = SWIG_AsVal_int(obj3, &val4);
34810 if (!SWIG_IsOK(ecode4)) {
34811 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34812 }
34813 arg4 = static_cast< int >(val4);
34814 }
34815 if (obj4) {
34816 ecode5 = SWIG_AsVal_int(obj4, &val5);
34817 if (!SWIG_IsOK(ecode5)) {
34818 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34819 }
34820 arg5 = static_cast< int >(val5);
34821 }
34822 if (obj5) {
34823 ecode6 = SWIG_AsVal_int(obj5, &val6);
34824 if (!SWIG_IsOK(ecode6)) {
34825 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34826 }
34827 arg6 = static_cast< int >(val6);
34828 }
34829 if (obj6) {
34830 ecode7 = SWIG_AsVal_int(obj6, &val7);
34831 if (!SWIG_IsOK(ecode7)) {
34832 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34833 }
34834 arg7 = static_cast< int >(val7);
34835 }
34836 {
34837 PyThreadState* __tstate = wxPyBeginAllowThreads();
34838 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
34839 wxPyEndAllowThreads(__tstate);
34840 if (PyErr_Occurred()) SWIG_fail;
34841 }
34842 resultobj = SWIG_Py_Void();
34843 return resultobj;
34844 fail:
34845 return NULL;
34846 }
34847
34848
34849 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34850 PyObject *resultobj = 0;
34851 wxWindow *arg1 = (wxWindow *) 0 ;
34852 wxSize *arg2 = 0 ;
34853 wxSize const &arg3_defvalue = wxDefaultSize ;
34854 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34855 wxSize const &arg4_defvalue = wxDefaultSize ;
34856 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
34857 void *argp1 = 0 ;
34858 int res1 = 0 ;
34859 wxSize temp2 ;
34860 wxSize temp3 ;
34861 wxSize temp4 ;
34862 PyObject * obj0 = 0 ;
34863 PyObject * obj1 = 0 ;
34864 PyObject * obj2 = 0 ;
34865 PyObject * obj3 = 0 ;
34866 char * kwnames[] = {
34867 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
34868 };
34869
34870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34872 if (!SWIG_IsOK(res1)) {
34873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34874 }
34875 arg1 = reinterpret_cast< wxWindow * >(argp1);
34876 {
34877 arg2 = &temp2;
34878 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34879 }
34880 if (obj2) {
34881 {
34882 arg3 = &temp3;
34883 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34884 }
34885 }
34886 if (obj3) {
34887 {
34888 arg4 = &temp4;
34889 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
34890 }
34891 }
34892 {
34893 PyThreadState* __tstate = wxPyBeginAllowThreads();
34894 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
34895 wxPyEndAllowThreads(__tstate);
34896 if (PyErr_Occurred()) SWIG_fail;
34897 }
34898 resultobj = SWIG_Py_Void();
34899 return resultobj;
34900 fail:
34901 return NULL;
34902 }
34903
34904
34905 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34906 PyObject *resultobj = 0;
34907 wxWindow *arg1 = (wxWindow *) 0 ;
34908 int arg2 ;
34909 int arg3 ;
34910 int arg4 = (int) -1 ;
34911 int arg5 = (int) -1 ;
34912 void *argp1 = 0 ;
34913 int res1 = 0 ;
34914 int val2 ;
34915 int ecode2 = 0 ;
34916 int val3 ;
34917 int ecode3 = 0 ;
34918 int val4 ;
34919 int ecode4 = 0 ;
34920 int val5 ;
34921 int ecode5 = 0 ;
34922 PyObject * obj0 = 0 ;
34923 PyObject * obj1 = 0 ;
34924 PyObject * obj2 = 0 ;
34925 PyObject * obj3 = 0 ;
34926 PyObject * obj4 = 0 ;
34927 char * kwnames[] = {
34928 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
34929 };
34930
34931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34933 if (!SWIG_IsOK(res1)) {
34934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34935 }
34936 arg1 = reinterpret_cast< wxWindow * >(argp1);
34937 ecode2 = SWIG_AsVal_int(obj1, &val2);
34938 if (!SWIG_IsOK(ecode2)) {
34939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
34940 }
34941 arg2 = static_cast< int >(val2);
34942 ecode3 = SWIG_AsVal_int(obj2, &val3);
34943 if (!SWIG_IsOK(ecode3)) {
34944 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
34945 }
34946 arg3 = static_cast< int >(val3);
34947 if (obj3) {
34948 ecode4 = SWIG_AsVal_int(obj3, &val4);
34949 if (!SWIG_IsOK(ecode4)) {
34950 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
34951 }
34952 arg4 = static_cast< int >(val4);
34953 }
34954 if (obj4) {
34955 ecode5 = SWIG_AsVal_int(obj4, &val5);
34956 if (!SWIG_IsOK(ecode5)) {
34957 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
34958 }
34959 arg5 = static_cast< int >(val5);
34960 }
34961 {
34962 PyThreadState* __tstate = wxPyBeginAllowThreads();
34963 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
34964 wxPyEndAllowThreads(__tstate);
34965 if (PyErr_Occurred()) SWIG_fail;
34966 }
34967 resultobj = SWIG_Py_Void();
34968 return resultobj;
34969 fail:
34970 return NULL;
34971 }
34972
34973
34974 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34975 PyObject *resultobj = 0;
34976 wxWindow *arg1 = (wxWindow *) 0 ;
34977 wxSize *arg2 = 0 ;
34978 wxSize const &arg3_defvalue = wxDefaultSize ;
34979 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34980 void *argp1 = 0 ;
34981 int res1 = 0 ;
34982 wxSize temp2 ;
34983 wxSize temp3 ;
34984 PyObject * obj0 = 0 ;
34985 PyObject * obj1 = 0 ;
34986 PyObject * obj2 = 0 ;
34987 char * kwnames[] = {
34988 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
34989 };
34990
34991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34993 if (!SWIG_IsOK(res1)) {
34994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34995 }
34996 arg1 = reinterpret_cast< wxWindow * >(argp1);
34997 {
34998 arg2 = &temp2;
34999 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35000 }
35001 if (obj2) {
35002 {
35003 arg3 = &temp3;
35004 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35005 }
35006 }
35007 {
35008 PyThreadState* __tstate = wxPyBeginAllowThreads();
35009 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35010 wxPyEndAllowThreads(__tstate);
35011 if (PyErr_Occurred()) SWIG_fail;
35012 }
35013 resultobj = SWIG_Py_Void();
35014 return resultobj;
35015 fail:
35016 return NULL;
35017 }
35018
35019
35020 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35021 PyObject *resultobj = 0;
35022 wxWindow *arg1 = (wxWindow *) 0 ;
35023 wxSize result;
35024 void *argp1 = 0 ;
35025 int res1 = 0 ;
35026 PyObject *swig_obj[1] ;
35027
35028 if (!args) SWIG_fail;
35029 swig_obj[0] = args;
35030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35031 if (!SWIG_IsOK(res1)) {
35032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35033 }
35034 arg1 = reinterpret_cast< wxWindow * >(argp1);
35035 {
35036 PyThreadState* __tstate = wxPyBeginAllowThreads();
35037 result = ((wxWindow const *)arg1)->GetMaxSize();
35038 wxPyEndAllowThreads(__tstate);
35039 if (PyErr_Occurred()) SWIG_fail;
35040 }
35041 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35042 return resultobj;
35043 fail:
35044 return NULL;
35045 }
35046
35047
35048 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35049 PyObject *resultobj = 0;
35050 wxWindow *arg1 = (wxWindow *) 0 ;
35051 wxSize result;
35052 void *argp1 = 0 ;
35053 int res1 = 0 ;
35054 PyObject *swig_obj[1] ;
35055
35056 if (!args) SWIG_fail;
35057 swig_obj[0] = args;
35058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35059 if (!SWIG_IsOK(res1)) {
35060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35061 }
35062 arg1 = reinterpret_cast< wxWindow * >(argp1);
35063 {
35064 PyThreadState* __tstate = wxPyBeginAllowThreads();
35065 result = ((wxWindow const *)arg1)->GetMinSize();
35066 wxPyEndAllowThreads(__tstate);
35067 if (PyErr_Occurred()) SWIG_fail;
35068 }
35069 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35070 return resultobj;
35071 fail:
35072 return NULL;
35073 }
35074
35075
35076 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35077 PyObject *resultobj = 0;
35078 wxWindow *arg1 = (wxWindow *) 0 ;
35079 wxSize *arg2 = 0 ;
35080 void *argp1 = 0 ;
35081 int res1 = 0 ;
35082 wxSize temp2 ;
35083 PyObject * obj0 = 0 ;
35084 PyObject * obj1 = 0 ;
35085 char * kwnames[] = {
35086 (char *) "self",(char *) "minSize", NULL
35087 };
35088
35089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35091 if (!SWIG_IsOK(res1)) {
35092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35093 }
35094 arg1 = reinterpret_cast< wxWindow * >(argp1);
35095 {
35096 arg2 = &temp2;
35097 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35098 }
35099 {
35100 PyThreadState* __tstate = wxPyBeginAllowThreads();
35101 (arg1)->SetMinSize((wxSize const &)*arg2);
35102 wxPyEndAllowThreads(__tstate);
35103 if (PyErr_Occurred()) SWIG_fail;
35104 }
35105 resultobj = SWIG_Py_Void();
35106 return resultobj;
35107 fail:
35108 return NULL;
35109 }
35110
35111
35112 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35113 PyObject *resultobj = 0;
35114 wxWindow *arg1 = (wxWindow *) 0 ;
35115 wxSize *arg2 = 0 ;
35116 void *argp1 = 0 ;
35117 int res1 = 0 ;
35118 wxSize temp2 ;
35119 PyObject * obj0 = 0 ;
35120 PyObject * obj1 = 0 ;
35121 char * kwnames[] = {
35122 (char *) "self",(char *) "maxSize", NULL
35123 };
35124
35125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35127 if (!SWIG_IsOK(res1)) {
35128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35129 }
35130 arg1 = reinterpret_cast< wxWindow * >(argp1);
35131 {
35132 arg2 = &temp2;
35133 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35134 }
35135 {
35136 PyThreadState* __tstate = wxPyBeginAllowThreads();
35137 (arg1)->SetMaxSize((wxSize const &)*arg2);
35138 wxPyEndAllowThreads(__tstate);
35139 if (PyErr_Occurred()) SWIG_fail;
35140 }
35141 resultobj = SWIG_Py_Void();
35142 return resultobj;
35143 fail:
35144 return NULL;
35145 }
35146
35147
35148 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35149 PyObject *resultobj = 0;
35150 wxWindow *arg1 = (wxWindow *) 0 ;
35151 int result;
35152 void *argp1 = 0 ;
35153 int res1 = 0 ;
35154 PyObject *swig_obj[1] ;
35155
35156 if (!args) SWIG_fail;
35157 swig_obj[0] = args;
35158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35159 if (!SWIG_IsOK(res1)) {
35160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35161 }
35162 arg1 = reinterpret_cast< wxWindow * >(argp1);
35163 {
35164 PyThreadState* __tstate = wxPyBeginAllowThreads();
35165 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35166 wxPyEndAllowThreads(__tstate);
35167 if (PyErr_Occurred()) SWIG_fail;
35168 }
35169 resultobj = SWIG_From_int(static_cast< int >(result));
35170 return resultobj;
35171 fail:
35172 return NULL;
35173 }
35174
35175
35176 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35177 PyObject *resultobj = 0;
35178 wxWindow *arg1 = (wxWindow *) 0 ;
35179 int result;
35180 void *argp1 = 0 ;
35181 int res1 = 0 ;
35182 PyObject *swig_obj[1] ;
35183
35184 if (!args) SWIG_fail;
35185 swig_obj[0] = args;
35186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35187 if (!SWIG_IsOK(res1)) {
35188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35189 }
35190 arg1 = reinterpret_cast< wxWindow * >(argp1);
35191 {
35192 PyThreadState* __tstate = wxPyBeginAllowThreads();
35193 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35194 wxPyEndAllowThreads(__tstate);
35195 if (PyErr_Occurred()) SWIG_fail;
35196 }
35197 resultobj = SWIG_From_int(static_cast< int >(result));
35198 return resultobj;
35199 fail:
35200 return NULL;
35201 }
35202
35203
35204 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35205 PyObject *resultobj = 0;
35206 wxWindow *arg1 = (wxWindow *) 0 ;
35207 int result;
35208 void *argp1 = 0 ;
35209 int res1 = 0 ;
35210 PyObject *swig_obj[1] ;
35211
35212 if (!args) SWIG_fail;
35213 swig_obj[0] = args;
35214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35215 if (!SWIG_IsOK(res1)) {
35216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35217 }
35218 arg1 = reinterpret_cast< wxWindow * >(argp1);
35219 {
35220 PyThreadState* __tstate = wxPyBeginAllowThreads();
35221 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35222 wxPyEndAllowThreads(__tstate);
35223 if (PyErr_Occurred()) SWIG_fail;
35224 }
35225 resultobj = SWIG_From_int(static_cast< int >(result));
35226 return resultobj;
35227 fail:
35228 return NULL;
35229 }
35230
35231
35232 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35233 PyObject *resultobj = 0;
35234 wxWindow *arg1 = (wxWindow *) 0 ;
35235 int result;
35236 void *argp1 = 0 ;
35237 int res1 = 0 ;
35238 PyObject *swig_obj[1] ;
35239
35240 if (!args) SWIG_fail;
35241 swig_obj[0] = args;
35242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35243 if (!SWIG_IsOK(res1)) {
35244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35245 }
35246 arg1 = reinterpret_cast< wxWindow * >(argp1);
35247 {
35248 PyThreadState* __tstate = wxPyBeginAllowThreads();
35249 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35250 wxPyEndAllowThreads(__tstate);
35251 if (PyErr_Occurred()) SWIG_fail;
35252 }
35253 resultobj = SWIG_From_int(static_cast< int >(result));
35254 return resultobj;
35255 fail:
35256 return NULL;
35257 }
35258
35259
35260 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35261 PyObject *resultobj = 0;
35262 wxWindow *arg1 = (wxWindow *) 0 ;
35263 wxSize *arg2 = 0 ;
35264 void *argp1 = 0 ;
35265 int res1 = 0 ;
35266 wxSize temp2 ;
35267 PyObject * obj0 = 0 ;
35268 PyObject * obj1 = 0 ;
35269 char * kwnames[] = {
35270 (char *) "self",(char *) "size", NULL
35271 };
35272
35273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35275 if (!SWIG_IsOK(res1)) {
35276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35277 }
35278 arg1 = reinterpret_cast< wxWindow * >(argp1);
35279 {
35280 arg2 = &temp2;
35281 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35282 }
35283 {
35284 PyThreadState* __tstate = wxPyBeginAllowThreads();
35285 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35286 wxPyEndAllowThreads(__tstate);
35287 if (PyErr_Occurred()) SWIG_fail;
35288 }
35289 resultobj = SWIG_Py_Void();
35290 return resultobj;
35291 fail:
35292 return NULL;
35293 }
35294
35295
35296 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35297 PyObject *resultobj = 0;
35298 wxWindow *arg1 = (wxWindow *) 0 ;
35299 int arg2 ;
35300 int arg3 ;
35301 void *argp1 = 0 ;
35302 int res1 = 0 ;
35303 int val2 ;
35304 int ecode2 = 0 ;
35305 int val3 ;
35306 int ecode3 = 0 ;
35307 PyObject * obj0 = 0 ;
35308 PyObject * obj1 = 0 ;
35309 PyObject * obj2 = 0 ;
35310 char * kwnames[] = {
35311 (char *) "self",(char *) "w",(char *) "h", NULL
35312 };
35313
35314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35316 if (!SWIG_IsOK(res1)) {
35317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35318 }
35319 arg1 = reinterpret_cast< wxWindow * >(argp1);
35320 ecode2 = SWIG_AsVal_int(obj1, &val2);
35321 if (!SWIG_IsOK(ecode2)) {
35322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35323 }
35324 arg2 = static_cast< int >(val2);
35325 ecode3 = SWIG_AsVal_int(obj2, &val3);
35326 if (!SWIG_IsOK(ecode3)) {
35327 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35328 }
35329 arg3 = static_cast< int >(val3);
35330 {
35331 PyThreadState* __tstate = wxPyBeginAllowThreads();
35332 (arg1)->SetVirtualSize(arg2,arg3);
35333 wxPyEndAllowThreads(__tstate);
35334 if (PyErr_Occurred()) SWIG_fail;
35335 }
35336 resultobj = SWIG_Py_Void();
35337 return resultobj;
35338 fail:
35339 return NULL;
35340 }
35341
35342
35343 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35344 PyObject *resultobj = 0;
35345 wxWindow *arg1 = (wxWindow *) 0 ;
35346 wxSize result;
35347 void *argp1 = 0 ;
35348 int res1 = 0 ;
35349 PyObject *swig_obj[1] ;
35350
35351 if (!args) SWIG_fail;
35352 swig_obj[0] = args;
35353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35354 if (!SWIG_IsOK(res1)) {
35355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35356 }
35357 arg1 = reinterpret_cast< wxWindow * >(argp1);
35358 {
35359 PyThreadState* __tstate = wxPyBeginAllowThreads();
35360 result = ((wxWindow const *)arg1)->GetVirtualSize();
35361 wxPyEndAllowThreads(__tstate);
35362 if (PyErr_Occurred()) SWIG_fail;
35363 }
35364 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35365 return resultobj;
35366 fail:
35367 return NULL;
35368 }
35369
35370
35371 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35372 PyObject *resultobj = 0;
35373 wxWindow *arg1 = (wxWindow *) 0 ;
35374 int *arg2 = (int *) 0 ;
35375 int *arg3 = (int *) 0 ;
35376 void *argp1 = 0 ;
35377 int res1 = 0 ;
35378 int temp2 ;
35379 int res2 = SWIG_TMPOBJ ;
35380 int temp3 ;
35381 int res3 = SWIG_TMPOBJ ;
35382 PyObject *swig_obj[1] ;
35383
35384 arg2 = &temp2;
35385 arg3 = &temp3;
35386 if (!args) SWIG_fail;
35387 swig_obj[0] = args;
35388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35389 if (!SWIG_IsOK(res1)) {
35390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35391 }
35392 arg1 = reinterpret_cast< wxWindow * >(argp1);
35393 {
35394 PyThreadState* __tstate = wxPyBeginAllowThreads();
35395 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35396 wxPyEndAllowThreads(__tstate);
35397 if (PyErr_Occurred()) SWIG_fail;
35398 }
35399 resultobj = SWIG_Py_Void();
35400 if (SWIG_IsTmpObj(res2)) {
35401 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35402 } else {
35403 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35404 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35405 }
35406 if (SWIG_IsTmpObj(res3)) {
35407 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35408 } else {
35409 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35410 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35411 }
35412 return resultobj;
35413 fail:
35414 return NULL;
35415 }
35416
35417
35418 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35419 PyObject *resultobj = 0;
35420 wxWindow *arg1 = (wxWindow *) 0 ;
35421 wxSize result;
35422 void *argp1 = 0 ;
35423 int res1 = 0 ;
35424 PyObject *swig_obj[1] ;
35425
35426 if (!args) SWIG_fail;
35427 swig_obj[0] = args;
35428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35429 if (!SWIG_IsOK(res1)) {
35430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35431 }
35432 arg1 = reinterpret_cast< wxWindow * >(argp1);
35433 {
35434 PyThreadState* __tstate = wxPyBeginAllowThreads();
35435 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35436 wxPyEndAllowThreads(__tstate);
35437 if (PyErr_Occurred()) SWIG_fail;
35438 }
35439 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35440 return resultobj;
35441 fail:
35442 return NULL;
35443 }
35444
35445
35446 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35447 PyObject *resultobj = 0;
35448 wxWindow *arg1 = (wxWindow *) 0 ;
35449 bool arg2 = (bool) true ;
35450 bool result;
35451 void *argp1 = 0 ;
35452 int res1 = 0 ;
35453 bool val2 ;
35454 int ecode2 = 0 ;
35455 PyObject * obj0 = 0 ;
35456 PyObject * obj1 = 0 ;
35457 char * kwnames[] = {
35458 (char *) "self",(char *) "show", NULL
35459 };
35460
35461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35463 if (!SWIG_IsOK(res1)) {
35464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35465 }
35466 arg1 = reinterpret_cast< wxWindow * >(argp1);
35467 if (obj1) {
35468 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35469 if (!SWIG_IsOK(ecode2)) {
35470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35471 }
35472 arg2 = static_cast< bool >(val2);
35473 }
35474 {
35475 PyThreadState* __tstate = wxPyBeginAllowThreads();
35476 result = (bool)(arg1)->Show(arg2);
35477 wxPyEndAllowThreads(__tstate);
35478 if (PyErr_Occurred()) SWIG_fail;
35479 }
35480 {
35481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35482 }
35483 return resultobj;
35484 fail:
35485 return NULL;
35486 }
35487
35488
35489 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35490 PyObject *resultobj = 0;
35491 wxWindow *arg1 = (wxWindow *) 0 ;
35492 bool result;
35493 void *argp1 = 0 ;
35494 int res1 = 0 ;
35495 PyObject *swig_obj[1] ;
35496
35497 if (!args) SWIG_fail;
35498 swig_obj[0] = args;
35499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35500 if (!SWIG_IsOK(res1)) {
35501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35502 }
35503 arg1 = reinterpret_cast< wxWindow * >(argp1);
35504 {
35505 PyThreadState* __tstate = wxPyBeginAllowThreads();
35506 result = (bool)(arg1)->Hide();
35507 wxPyEndAllowThreads(__tstate);
35508 if (PyErr_Occurred()) SWIG_fail;
35509 }
35510 {
35511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35512 }
35513 return resultobj;
35514 fail:
35515 return NULL;
35516 }
35517
35518
35519 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35520 PyObject *resultobj = 0;
35521 wxWindow *arg1 = (wxWindow *) 0 ;
35522 bool arg2 = (bool) true ;
35523 bool result;
35524 void *argp1 = 0 ;
35525 int res1 = 0 ;
35526 bool val2 ;
35527 int ecode2 = 0 ;
35528 PyObject * obj0 = 0 ;
35529 PyObject * obj1 = 0 ;
35530 char * kwnames[] = {
35531 (char *) "self",(char *) "enable", NULL
35532 };
35533
35534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35536 if (!SWIG_IsOK(res1)) {
35537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35538 }
35539 arg1 = reinterpret_cast< wxWindow * >(argp1);
35540 if (obj1) {
35541 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35542 if (!SWIG_IsOK(ecode2)) {
35543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35544 }
35545 arg2 = static_cast< bool >(val2);
35546 }
35547 {
35548 PyThreadState* __tstate = wxPyBeginAllowThreads();
35549 result = (bool)(arg1)->Enable(arg2);
35550 wxPyEndAllowThreads(__tstate);
35551 if (PyErr_Occurred()) SWIG_fail;
35552 }
35553 {
35554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35555 }
35556 return resultobj;
35557 fail:
35558 return NULL;
35559 }
35560
35561
35562 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35563 PyObject *resultobj = 0;
35564 wxWindow *arg1 = (wxWindow *) 0 ;
35565 bool result;
35566 void *argp1 = 0 ;
35567 int res1 = 0 ;
35568 PyObject *swig_obj[1] ;
35569
35570 if (!args) SWIG_fail;
35571 swig_obj[0] = args;
35572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35573 if (!SWIG_IsOK(res1)) {
35574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35575 }
35576 arg1 = reinterpret_cast< wxWindow * >(argp1);
35577 {
35578 PyThreadState* __tstate = wxPyBeginAllowThreads();
35579 result = (bool)(arg1)->Disable();
35580 wxPyEndAllowThreads(__tstate);
35581 if (PyErr_Occurred()) SWIG_fail;
35582 }
35583 {
35584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35585 }
35586 return resultobj;
35587 fail:
35588 return NULL;
35589 }
35590
35591
35592 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35593 PyObject *resultobj = 0;
35594 wxWindow *arg1 = (wxWindow *) 0 ;
35595 bool result;
35596 void *argp1 = 0 ;
35597 int res1 = 0 ;
35598 PyObject *swig_obj[1] ;
35599
35600 if (!args) SWIG_fail;
35601 swig_obj[0] = args;
35602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35603 if (!SWIG_IsOK(res1)) {
35604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35605 }
35606 arg1 = reinterpret_cast< wxWindow * >(argp1);
35607 {
35608 PyThreadState* __tstate = wxPyBeginAllowThreads();
35609 result = (bool)((wxWindow const *)arg1)->IsShown();
35610 wxPyEndAllowThreads(__tstate);
35611 if (PyErr_Occurred()) SWIG_fail;
35612 }
35613 {
35614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35615 }
35616 return resultobj;
35617 fail:
35618 return NULL;
35619 }
35620
35621
35622 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35623 PyObject *resultobj = 0;
35624 wxWindow *arg1 = (wxWindow *) 0 ;
35625 bool result;
35626 void *argp1 = 0 ;
35627 int res1 = 0 ;
35628 PyObject *swig_obj[1] ;
35629
35630 if (!args) SWIG_fail;
35631 swig_obj[0] = args;
35632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35633 if (!SWIG_IsOK(res1)) {
35634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35635 }
35636 arg1 = reinterpret_cast< wxWindow * >(argp1);
35637 {
35638 PyThreadState* __tstate = wxPyBeginAllowThreads();
35639 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35640 wxPyEndAllowThreads(__tstate);
35641 if (PyErr_Occurred()) SWIG_fail;
35642 }
35643 {
35644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35645 }
35646 return resultobj;
35647 fail:
35648 return NULL;
35649 }
35650
35651
35652 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35653 PyObject *resultobj = 0;
35654 wxWindow *arg1 = (wxWindow *) 0 ;
35655 bool result;
35656 void *argp1 = 0 ;
35657 int res1 = 0 ;
35658 PyObject *swig_obj[1] ;
35659
35660 if (!args) SWIG_fail;
35661 swig_obj[0] = args;
35662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35663 if (!SWIG_IsOK(res1)) {
35664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35665 }
35666 arg1 = reinterpret_cast< wxWindow * >(argp1);
35667 {
35668 PyThreadState* __tstate = wxPyBeginAllowThreads();
35669 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35670 wxPyEndAllowThreads(__tstate);
35671 if (PyErr_Occurred()) SWIG_fail;
35672 }
35673 {
35674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35675 }
35676 return resultobj;
35677 fail:
35678 return NULL;
35679 }
35680
35681
35682 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35683 PyObject *resultobj = 0;
35684 wxWindow *arg1 = (wxWindow *) 0 ;
35685 long arg2 ;
35686 void *argp1 = 0 ;
35687 int res1 = 0 ;
35688 long val2 ;
35689 int ecode2 = 0 ;
35690 PyObject * obj0 = 0 ;
35691 PyObject * obj1 = 0 ;
35692 char * kwnames[] = {
35693 (char *) "self",(char *) "style", NULL
35694 };
35695
35696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35698 if (!SWIG_IsOK(res1)) {
35699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35700 }
35701 arg1 = reinterpret_cast< wxWindow * >(argp1);
35702 ecode2 = SWIG_AsVal_long(obj1, &val2);
35703 if (!SWIG_IsOK(ecode2)) {
35704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35705 }
35706 arg2 = static_cast< long >(val2);
35707 {
35708 PyThreadState* __tstate = wxPyBeginAllowThreads();
35709 (arg1)->SetWindowStyleFlag(arg2);
35710 wxPyEndAllowThreads(__tstate);
35711 if (PyErr_Occurred()) SWIG_fail;
35712 }
35713 resultobj = SWIG_Py_Void();
35714 return resultobj;
35715 fail:
35716 return NULL;
35717 }
35718
35719
35720 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35721 PyObject *resultobj = 0;
35722 wxWindow *arg1 = (wxWindow *) 0 ;
35723 long result;
35724 void *argp1 = 0 ;
35725 int res1 = 0 ;
35726 PyObject *swig_obj[1] ;
35727
35728 if (!args) SWIG_fail;
35729 swig_obj[0] = args;
35730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35731 if (!SWIG_IsOK(res1)) {
35732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35733 }
35734 arg1 = reinterpret_cast< wxWindow * >(argp1);
35735 {
35736 PyThreadState* __tstate = wxPyBeginAllowThreads();
35737 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35738 wxPyEndAllowThreads(__tstate);
35739 if (PyErr_Occurred()) SWIG_fail;
35740 }
35741 resultobj = SWIG_From_long(static_cast< long >(result));
35742 return resultobj;
35743 fail:
35744 return NULL;
35745 }
35746
35747
35748 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35749 PyObject *resultobj = 0;
35750 wxWindow *arg1 = (wxWindow *) 0 ;
35751 int arg2 ;
35752 bool result;
35753 void *argp1 = 0 ;
35754 int res1 = 0 ;
35755 int val2 ;
35756 int ecode2 = 0 ;
35757 PyObject * obj0 = 0 ;
35758 PyObject * obj1 = 0 ;
35759 char * kwnames[] = {
35760 (char *) "self",(char *) "flag", NULL
35761 };
35762
35763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35765 if (!SWIG_IsOK(res1)) {
35766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35767 }
35768 arg1 = reinterpret_cast< wxWindow * >(argp1);
35769 ecode2 = SWIG_AsVal_int(obj1, &val2);
35770 if (!SWIG_IsOK(ecode2)) {
35771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35772 }
35773 arg2 = static_cast< int >(val2);
35774 {
35775 PyThreadState* __tstate = wxPyBeginAllowThreads();
35776 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35777 wxPyEndAllowThreads(__tstate);
35778 if (PyErr_Occurred()) SWIG_fail;
35779 }
35780 {
35781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35782 }
35783 return resultobj;
35784 fail:
35785 return NULL;
35786 }
35787
35788
35789 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35790 PyObject *resultobj = 0;
35791 wxWindow *arg1 = (wxWindow *) 0 ;
35792 bool result;
35793 void *argp1 = 0 ;
35794 int res1 = 0 ;
35795 PyObject *swig_obj[1] ;
35796
35797 if (!args) SWIG_fail;
35798 swig_obj[0] = args;
35799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35800 if (!SWIG_IsOK(res1)) {
35801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
35802 }
35803 arg1 = reinterpret_cast< wxWindow * >(argp1);
35804 {
35805 PyThreadState* __tstate = wxPyBeginAllowThreads();
35806 result = (bool)((wxWindow const *)arg1)->IsRetained();
35807 wxPyEndAllowThreads(__tstate);
35808 if (PyErr_Occurred()) SWIG_fail;
35809 }
35810 {
35811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35812 }
35813 return resultobj;
35814 fail:
35815 return NULL;
35816 }
35817
35818
35819 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35820 PyObject *resultobj = 0;
35821 wxWindow *arg1 = (wxWindow *) 0 ;
35822 long arg2 ;
35823 void *argp1 = 0 ;
35824 int res1 = 0 ;
35825 long val2 ;
35826 int ecode2 = 0 ;
35827 PyObject * obj0 = 0 ;
35828 PyObject * obj1 = 0 ;
35829 char * kwnames[] = {
35830 (char *) "self",(char *) "exStyle", NULL
35831 };
35832
35833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35835 if (!SWIG_IsOK(res1)) {
35836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35837 }
35838 arg1 = reinterpret_cast< wxWindow * >(argp1);
35839 ecode2 = SWIG_AsVal_long(obj1, &val2);
35840 if (!SWIG_IsOK(ecode2)) {
35841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
35842 }
35843 arg2 = static_cast< long >(val2);
35844 {
35845 PyThreadState* __tstate = wxPyBeginAllowThreads();
35846 (arg1)->SetExtraStyle(arg2);
35847 wxPyEndAllowThreads(__tstate);
35848 if (PyErr_Occurred()) SWIG_fail;
35849 }
35850 resultobj = SWIG_Py_Void();
35851 return resultobj;
35852 fail:
35853 return NULL;
35854 }
35855
35856
35857 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35858 PyObject *resultobj = 0;
35859 wxWindow *arg1 = (wxWindow *) 0 ;
35860 long result;
35861 void *argp1 = 0 ;
35862 int res1 = 0 ;
35863 PyObject *swig_obj[1] ;
35864
35865 if (!args) SWIG_fail;
35866 swig_obj[0] = args;
35867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35868 if (!SWIG_IsOK(res1)) {
35869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35870 }
35871 arg1 = reinterpret_cast< wxWindow * >(argp1);
35872 {
35873 PyThreadState* __tstate = wxPyBeginAllowThreads();
35874 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
35875 wxPyEndAllowThreads(__tstate);
35876 if (PyErr_Occurred()) SWIG_fail;
35877 }
35878 resultobj = SWIG_From_long(static_cast< long >(result));
35879 return resultobj;
35880 fail:
35881 return NULL;
35882 }
35883
35884
35885 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35886 PyObject *resultobj = 0;
35887 wxWindow *arg1 = (wxWindow *) 0 ;
35888 bool arg2 = (bool) true ;
35889 void *argp1 = 0 ;
35890 int res1 = 0 ;
35891 bool val2 ;
35892 int ecode2 = 0 ;
35893 PyObject * obj0 = 0 ;
35894 PyObject * obj1 = 0 ;
35895 char * kwnames[] = {
35896 (char *) "self",(char *) "modal", NULL
35897 };
35898
35899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
35900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35901 if (!SWIG_IsOK(res1)) {
35902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
35903 }
35904 arg1 = reinterpret_cast< wxWindow * >(argp1);
35905 if (obj1) {
35906 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35907 if (!SWIG_IsOK(ecode2)) {
35908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
35909 }
35910 arg2 = static_cast< bool >(val2);
35911 }
35912 {
35913 PyThreadState* __tstate = wxPyBeginAllowThreads();
35914 (arg1)->MakeModal(arg2);
35915 wxPyEndAllowThreads(__tstate);
35916 if (PyErr_Occurred()) SWIG_fail;
35917 }
35918 resultobj = SWIG_Py_Void();
35919 return resultobj;
35920 fail:
35921 return NULL;
35922 }
35923
35924
35925 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35926 PyObject *resultobj = 0;
35927 wxWindow *arg1 = (wxWindow *) 0 ;
35928 bool arg2 ;
35929 void *argp1 = 0 ;
35930 int res1 = 0 ;
35931 bool val2 ;
35932 int ecode2 = 0 ;
35933 PyObject * obj0 = 0 ;
35934 PyObject * obj1 = 0 ;
35935 char * kwnames[] = {
35936 (char *) "self",(char *) "enableTheme", NULL
35937 };
35938
35939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
35940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35941 if (!SWIG_IsOK(res1)) {
35942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
35943 }
35944 arg1 = reinterpret_cast< wxWindow * >(argp1);
35945 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35946 if (!SWIG_IsOK(ecode2)) {
35947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
35948 }
35949 arg2 = static_cast< bool >(val2);
35950 {
35951 PyThreadState* __tstate = wxPyBeginAllowThreads();
35952 (arg1)->SetThemeEnabled(arg2);
35953 wxPyEndAllowThreads(__tstate);
35954 if (PyErr_Occurred()) SWIG_fail;
35955 }
35956 resultobj = SWIG_Py_Void();
35957 return resultobj;
35958 fail:
35959 return NULL;
35960 }
35961
35962
35963 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35964 PyObject *resultobj = 0;
35965 wxWindow *arg1 = (wxWindow *) 0 ;
35966 bool result;
35967 void *argp1 = 0 ;
35968 int res1 = 0 ;
35969 PyObject *swig_obj[1] ;
35970
35971 if (!args) SWIG_fail;
35972 swig_obj[0] = args;
35973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35974 if (!SWIG_IsOK(res1)) {
35975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35976 }
35977 arg1 = reinterpret_cast< wxWindow * >(argp1);
35978 {
35979 PyThreadState* __tstate = wxPyBeginAllowThreads();
35980 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
35981 wxPyEndAllowThreads(__tstate);
35982 if (PyErr_Occurred()) SWIG_fail;
35983 }
35984 {
35985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35986 }
35987 return resultobj;
35988 fail:
35989 return NULL;
35990 }
35991
35992
35993 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35994 PyObject *resultobj = 0;
35995 wxWindow *arg1 = (wxWindow *) 0 ;
35996 void *argp1 = 0 ;
35997 int res1 = 0 ;
35998 PyObject *swig_obj[1] ;
35999
36000 if (!args) SWIG_fail;
36001 swig_obj[0] = args;
36002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36003 if (!SWIG_IsOK(res1)) {
36004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36005 }
36006 arg1 = reinterpret_cast< wxWindow * >(argp1);
36007 {
36008 PyThreadState* __tstate = wxPyBeginAllowThreads();
36009 (arg1)->SetFocus();
36010 wxPyEndAllowThreads(__tstate);
36011 if (PyErr_Occurred()) SWIG_fail;
36012 }
36013 resultobj = SWIG_Py_Void();
36014 return resultobj;
36015 fail:
36016 return NULL;
36017 }
36018
36019
36020 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36021 PyObject *resultobj = 0;
36022 wxWindow *arg1 = (wxWindow *) 0 ;
36023 void *argp1 = 0 ;
36024 int res1 = 0 ;
36025 PyObject *swig_obj[1] ;
36026
36027 if (!args) SWIG_fail;
36028 swig_obj[0] = args;
36029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36030 if (!SWIG_IsOK(res1)) {
36031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36032 }
36033 arg1 = reinterpret_cast< wxWindow * >(argp1);
36034 {
36035 PyThreadState* __tstate = wxPyBeginAllowThreads();
36036 (arg1)->SetFocusFromKbd();
36037 wxPyEndAllowThreads(__tstate);
36038 if (PyErr_Occurred()) SWIG_fail;
36039 }
36040 resultobj = SWIG_Py_Void();
36041 return resultobj;
36042 fail:
36043 return NULL;
36044 }
36045
36046
36047 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36048 PyObject *resultobj = 0;
36049 wxWindow *result = 0 ;
36050
36051 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36052 {
36053 if (!wxPyCheckForApp()) SWIG_fail;
36054 PyThreadState* __tstate = wxPyBeginAllowThreads();
36055 result = (wxWindow *)wxWindow::FindFocus();
36056 wxPyEndAllowThreads(__tstate);
36057 if (PyErr_Occurred()) SWIG_fail;
36058 }
36059 {
36060 resultobj = wxPyMake_wxObject(result, 0);
36061 }
36062 return resultobj;
36063 fail:
36064 return NULL;
36065 }
36066
36067
36068 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36069 PyObject *resultobj = 0;
36070 wxWindow *arg1 = (wxWindow *) 0 ;
36071 bool result;
36072 void *argp1 = 0 ;
36073 int res1 = 0 ;
36074 PyObject *swig_obj[1] ;
36075
36076 if (!args) SWIG_fail;
36077 swig_obj[0] = args;
36078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36079 if (!SWIG_IsOK(res1)) {
36080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36081 }
36082 arg1 = reinterpret_cast< wxWindow * >(argp1);
36083 {
36084 PyThreadState* __tstate = wxPyBeginAllowThreads();
36085 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36086 wxPyEndAllowThreads(__tstate);
36087 if (PyErr_Occurred()) SWIG_fail;
36088 }
36089 {
36090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36091 }
36092 return resultobj;
36093 fail:
36094 return NULL;
36095 }
36096
36097
36098 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36099 PyObject *resultobj = 0;
36100 wxWindow *arg1 = (wxWindow *) 0 ;
36101 bool result;
36102 void *argp1 = 0 ;
36103 int res1 = 0 ;
36104 PyObject *swig_obj[1] ;
36105
36106 if (!args) SWIG_fail;
36107 swig_obj[0] = args;
36108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36109 if (!SWIG_IsOK(res1)) {
36110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36111 }
36112 arg1 = reinterpret_cast< wxWindow * >(argp1);
36113 {
36114 PyThreadState* __tstate = wxPyBeginAllowThreads();
36115 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36116 wxPyEndAllowThreads(__tstate);
36117 if (PyErr_Occurred()) SWIG_fail;
36118 }
36119 {
36120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36121 }
36122 return resultobj;
36123 fail:
36124 return NULL;
36125 }
36126
36127
36128 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36129 PyObject *resultobj = 0;
36130 wxWindow *arg1 = (wxWindow *) 0 ;
36131 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36132 bool result;
36133 void *argp1 = 0 ;
36134 int res1 = 0 ;
36135 int val2 ;
36136 int ecode2 = 0 ;
36137 PyObject * obj0 = 0 ;
36138 PyObject * obj1 = 0 ;
36139 char * kwnames[] = {
36140 (char *) "self",(char *) "flags", NULL
36141 };
36142
36143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36145 if (!SWIG_IsOK(res1)) {
36146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36147 }
36148 arg1 = reinterpret_cast< wxWindow * >(argp1);
36149 if (obj1) {
36150 ecode2 = SWIG_AsVal_int(obj1, &val2);
36151 if (!SWIG_IsOK(ecode2)) {
36152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36153 }
36154 arg2 = static_cast< int >(val2);
36155 }
36156 {
36157 PyThreadState* __tstate = wxPyBeginAllowThreads();
36158 result = (bool)(arg1)->Navigate(arg2);
36159 wxPyEndAllowThreads(__tstate);
36160 if (PyErr_Occurred()) SWIG_fail;
36161 }
36162 {
36163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36164 }
36165 return resultobj;
36166 fail:
36167 return NULL;
36168 }
36169
36170
36171 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36172 PyObject *resultobj = 0;
36173 wxWindow *arg1 = (wxWindow *) 0 ;
36174 wxWindow *arg2 = (wxWindow *) 0 ;
36175 void *argp1 = 0 ;
36176 int res1 = 0 ;
36177 void *argp2 = 0 ;
36178 int res2 = 0 ;
36179 PyObject * obj0 = 0 ;
36180 PyObject * obj1 = 0 ;
36181 char * kwnames[] = {
36182 (char *) "self",(char *) "win", NULL
36183 };
36184
36185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36187 if (!SWIG_IsOK(res1)) {
36188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36189 }
36190 arg1 = reinterpret_cast< wxWindow * >(argp1);
36191 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36192 if (!SWIG_IsOK(res2)) {
36193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36194 }
36195 arg2 = reinterpret_cast< wxWindow * >(argp2);
36196 {
36197 PyThreadState* __tstate = wxPyBeginAllowThreads();
36198 (arg1)->MoveAfterInTabOrder(arg2);
36199 wxPyEndAllowThreads(__tstate);
36200 if (PyErr_Occurred()) SWIG_fail;
36201 }
36202 resultobj = SWIG_Py_Void();
36203 return resultobj;
36204 fail:
36205 return NULL;
36206 }
36207
36208
36209 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36210 PyObject *resultobj = 0;
36211 wxWindow *arg1 = (wxWindow *) 0 ;
36212 wxWindow *arg2 = (wxWindow *) 0 ;
36213 void *argp1 = 0 ;
36214 int res1 = 0 ;
36215 void *argp2 = 0 ;
36216 int res2 = 0 ;
36217 PyObject * obj0 = 0 ;
36218 PyObject * obj1 = 0 ;
36219 char * kwnames[] = {
36220 (char *) "self",(char *) "win", NULL
36221 };
36222
36223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36225 if (!SWIG_IsOK(res1)) {
36226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36227 }
36228 arg1 = reinterpret_cast< wxWindow * >(argp1);
36229 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36230 if (!SWIG_IsOK(res2)) {
36231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36232 }
36233 arg2 = reinterpret_cast< wxWindow * >(argp2);
36234 {
36235 PyThreadState* __tstate = wxPyBeginAllowThreads();
36236 (arg1)->MoveBeforeInTabOrder(arg2);
36237 wxPyEndAllowThreads(__tstate);
36238 if (PyErr_Occurred()) SWIG_fail;
36239 }
36240 resultobj = SWIG_Py_Void();
36241 return resultobj;
36242 fail:
36243 return NULL;
36244 }
36245
36246
36247 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36248 PyObject *resultobj = 0;
36249 wxWindow *arg1 = (wxWindow *) 0 ;
36250 PyObject *result = 0 ;
36251 void *argp1 = 0 ;
36252 int res1 = 0 ;
36253 PyObject *swig_obj[1] ;
36254
36255 if (!args) SWIG_fail;
36256 swig_obj[0] = args;
36257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36258 if (!SWIG_IsOK(res1)) {
36259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36260 }
36261 arg1 = reinterpret_cast< wxWindow * >(argp1);
36262 {
36263 PyThreadState* __tstate = wxPyBeginAllowThreads();
36264 result = (PyObject *)wxWindow_GetChildren(arg1);
36265 wxPyEndAllowThreads(__tstate);
36266 if (PyErr_Occurred()) SWIG_fail;
36267 }
36268 resultobj = result;
36269 return resultobj;
36270 fail:
36271 return NULL;
36272 }
36273
36274
36275 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36276 PyObject *resultobj = 0;
36277 wxWindow *arg1 = (wxWindow *) 0 ;
36278 wxWindow *result = 0 ;
36279 void *argp1 = 0 ;
36280 int res1 = 0 ;
36281 PyObject *swig_obj[1] ;
36282
36283 if (!args) SWIG_fail;
36284 swig_obj[0] = args;
36285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36286 if (!SWIG_IsOK(res1)) {
36287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36288 }
36289 arg1 = reinterpret_cast< wxWindow * >(argp1);
36290 {
36291 PyThreadState* __tstate = wxPyBeginAllowThreads();
36292 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36293 wxPyEndAllowThreads(__tstate);
36294 if (PyErr_Occurred()) SWIG_fail;
36295 }
36296 {
36297 resultobj = wxPyMake_wxObject(result, 0);
36298 }
36299 return resultobj;
36300 fail:
36301 return NULL;
36302 }
36303
36304
36305 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36306 PyObject *resultobj = 0;
36307 wxWindow *arg1 = (wxWindow *) 0 ;
36308 wxWindow *result = 0 ;
36309 void *argp1 = 0 ;
36310 int res1 = 0 ;
36311 PyObject *swig_obj[1] ;
36312
36313 if (!args) SWIG_fail;
36314 swig_obj[0] = args;
36315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36316 if (!SWIG_IsOK(res1)) {
36317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36318 }
36319 arg1 = reinterpret_cast< wxWindow * >(argp1);
36320 {
36321 PyThreadState* __tstate = wxPyBeginAllowThreads();
36322 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36323 wxPyEndAllowThreads(__tstate);
36324 if (PyErr_Occurred()) SWIG_fail;
36325 }
36326 {
36327 resultobj = wxPyMake_wxObject(result, 0);
36328 }
36329 return resultobj;
36330 fail:
36331 return NULL;
36332 }
36333
36334
36335 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36336 PyObject *resultobj = 0;
36337 wxWindow *arg1 = (wxWindow *) 0 ;
36338 bool result;
36339 void *argp1 = 0 ;
36340 int res1 = 0 ;
36341 PyObject *swig_obj[1] ;
36342
36343 if (!args) SWIG_fail;
36344 swig_obj[0] = args;
36345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36346 if (!SWIG_IsOK(res1)) {
36347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36348 }
36349 arg1 = reinterpret_cast< wxWindow * >(argp1);
36350 {
36351 PyThreadState* __tstate = wxPyBeginAllowThreads();
36352 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36353 wxPyEndAllowThreads(__tstate);
36354 if (PyErr_Occurred()) SWIG_fail;
36355 }
36356 {
36357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36358 }
36359 return resultobj;
36360 fail:
36361 return NULL;
36362 }
36363
36364
36365 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36366 PyObject *resultobj = 0;
36367 wxWindow *arg1 = (wxWindow *) 0 ;
36368 wxWindow *arg2 = (wxWindow *) 0 ;
36369 bool result;
36370 void *argp1 = 0 ;
36371 int res1 = 0 ;
36372 void *argp2 = 0 ;
36373 int res2 = 0 ;
36374 PyObject * obj0 = 0 ;
36375 PyObject * obj1 = 0 ;
36376 char * kwnames[] = {
36377 (char *) "self",(char *) "newParent", NULL
36378 };
36379
36380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36382 if (!SWIG_IsOK(res1)) {
36383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36384 }
36385 arg1 = reinterpret_cast< wxWindow * >(argp1);
36386 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36387 if (!SWIG_IsOK(res2)) {
36388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36389 }
36390 arg2 = reinterpret_cast< wxWindow * >(argp2);
36391 {
36392 PyThreadState* __tstate = wxPyBeginAllowThreads();
36393 result = (bool)(arg1)->Reparent(arg2);
36394 wxPyEndAllowThreads(__tstate);
36395 if (PyErr_Occurred()) SWIG_fail;
36396 }
36397 {
36398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36399 }
36400 return resultobj;
36401 fail:
36402 return NULL;
36403 }
36404
36405
36406 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36407 PyObject *resultobj = 0;
36408 wxWindow *arg1 = (wxWindow *) 0 ;
36409 wxWindow *arg2 = (wxWindow *) 0 ;
36410 void *argp1 = 0 ;
36411 int res1 = 0 ;
36412 void *argp2 = 0 ;
36413 int res2 = 0 ;
36414 PyObject * obj0 = 0 ;
36415 PyObject * obj1 = 0 ;
36416 char * kwnames[] = {
36417 (char *) "self",(char *) "child", NULL
36418 };
36419
36420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36422 if (!SWIG_IsOK(res1)) {
36423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36424 }
36425 arg1 = reinterpret_cast< wxWindow * >(argp1);
36426 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36427 if (!SWIG_IsOK(res2)) {
36428 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36429 }
36430 arg2 = reinterpret_cast< wxWindow * >(argp2);
36431 {
36432 PyThreadState* __tstate = wxPyBeginAllowThreads();
36433 (arg1)->AddChild(arg2);
36434 wxPyEndAllowThreads(__tstate);
36435 if (PyErr_Occurred()) SWIG_fail;
36436 }
36437 resultobj = SWIG_Py_Void();
36438 return resultobj;
36439 fail:
36440 return NULL;
36441 }
36442
36443
36444 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36445 PyObject *resultobj = 0;
36446 wxWindow *arg1 = (wxWindow *) 0 ;
36447 wxWindow *arg2 = (wxWindow *) 0 ;
36448 void *argp1 = 0 ;
36449 int res1 = 0 ;
36450 void *argp2 = 0 ;
36451 int res2 = 0 ;
36452 PyObject * obj0 = 0 ;
36453 PyObject * obj1 = 0 ;
36454 char * kwnames[] = {
36455 (char *) "self",(char *) "child", NULL
36456 };
36457
36458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36460 if (!SWIG_IsOK(res1)) {
36461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36462 }
36463 arg1 = reinterpret_cast< wxWindow * >(argp1);
36464 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36465 if (!SWIG_IsOK(res2)) {
36466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36467 }
36468 arg2 = reinterpret_cast< wxWindow * >(argp2);
36469 {
36470 PyThreadState* __tstate = wxPyBeginAllowThreads();
36471 (arg1)->RemoveChild(arg2);
36472 wxPyEndAllowThreads(__tstate);
36473 if (PyErr_Occurred()) SWIG_fail;
36474 }
36475 resultobj = SWIG_Py_Void();
36476 return resultobj;
36477 fail:
36478 return NULL;
36479 }
36480
36481
36482 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36483 PyObject *resultobj = 0;
36484 wxWindow *arg1 = (wxWindow *) 0 ;
36485 bool arg2 ;
36486 void *argp1 = 0 ;
36487 int res1 = 0 ;
36488 bool val2 ;
36489 int ecode2 = 0 ;
36490 PyObject * obj0 = 0 ;
36491 PyObject * obj1 = 0 ;
36492 char * kwnames[] = {
36493 (char *) "self",(char *) "on", NULL
36494 };
36495
36496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",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_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36500 }
36501 arg1 = reinterpret_cast< wxWindow * >(argp1);
36502 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36503 if (!SWIG_IsOK(ecode2)) {
36504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36505 }
36506 arg2 = static_cast< bool >(val2);
36507 {
36508 PyThreadState* __tstate = wxPyBeginAllowThreads();
36509 (arg1)->SetDoubleBuffered(arg2);
36510 wxPyEndAllowThreads(__tstate);
36511 if (PyErr_Occurred()) SWIG_fail;
36512 }
36513 resultobj = SWIG_Py_Void();
36514 return resultobj;
36515 fail:
36516 return NULL;
36517 }
36518
36519
36520 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36521 PyObject *resultobj = 0;
36522 wxWindow *arg1 = (wxWindow *) 0 ;
36523 long arg2 ;
36524 wxWindow *result = 0 ;
36525 void *argp1 = 0 ;
36526 int res1 = 0 ;
36527 long val2 ;
36528 int ecode2 = 0 ;
36529 PyObject * obj0 = 0 ;
36530 PyObject * obj1 = 0 ;
36531 char * kwnames[] = {
36532 (char *) "self",(char *) "winid", NULL
36533 };
36534
36535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36537 if (!SWIG_IsOK(res1)) {
36538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36539 }
36540 arg1 = reinterpret_cast< wxWindow * >(argp1);
36541 ecode2 = SWIG_AsVal_long(obj1, &val2);
36542 if (!SWIG_IsOK(ecode2)) {
36543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36544 }
36545 arg2 = static_cast< long >(val2);
36546 {
36547 PyThreadState* __tstate = wxPyBeginAllowThreads();
36548 result = (wxWindow *)(arg1)->FindWindow(arg2);
36549 wxPyEndAllowThreads(__tstate);
36550 if (PyErr_Occurred()) SWIG_fail;
36551 }
36552 {
36553 resultobj = wxPyMake_wxObject(result, 0);
36554 }
36555 return resultobj;
36556 fail:
36557 return NULL;
36558 }
36559
36560
36561 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36562 PyObject *resultobj = 0;
36563 wxWindow *arg1 = (wxWindow *) 0 ;
36564 wxString *arg2 = 0 ;
36565 wxWindow *result = 0 ;
36566 void *argp1 = 0 ;
36567 int res1 = 0 ;
36568 bool temp2 = false ;
36569 PyObject * obj0 = 0 ;
36570 PyObject * obj1 = 0 ;
36571 char * kwnames[] = {
36572 (char *) "self",(char *) "name", NULL
36573 };
36574
36575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36577 if (!SWIG_IsOK(res1)) {
36578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36579 }
36580 arg1 = reinterpret_cast< wxWindow * >(argp1);
36581 {
36582 arg2 = wxString_in_helper(obj1);
36583 if (arg2 == NULL) SWIG_fail;
36584 temp2 = true;
36585 }
36586 {
36587 PyThreadState* __tstate = wxPyBeginAllowThreads();
36588 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36589 wxPyEndAllowThreads(__tstate);
36590 if (PyErr_Occurred()) SWIG_fail;
36591 }
36592 {
36593 resultobj = wxPyMake_wxObject(result, 0);
36594 }
36595 {
36596 if (temp2)
36597 delete arg2;
36598 }
36599 return resultobj;
36600 fail:
36601 {
36602 if (temp2)
36603 delete arg2;
36604 }
36605 return NULL;
36606 }
36607
36608
36609 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36610 PyObject *resultobj = 0;
36611 wxWindow *arg1 = (wxWindow *) 0 ;
36612 wxEvtHandler *result = 0 ;
36613 void *argp1 = 0 ;
36614 int res1 = 0 ;
36615 PyObject *swig_obj[1] ;
36616
36617 if (!args) SWIG_fail;
36618 swig_obj[0] = args;
36619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36620 if (!SWIG_IsOK(res1)) {
36621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36622 }
36623 arg1 = reinterpret_cast< wxWindow * >(argp1);
36624 {
36625 PyThreadState* __tstate = wxPyBeginAllowThreads();
36626 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36627 wxPyEndAllowThreads(__tstate);
36628 if (PyErr_Occurred()) SWIG_fail;
36629 }
36630 {
36631 resultobj = wxPyMake_wxObject(result, 0);
36632 }
36633 return resultobj;
36634 fail:
36635 return NULL;
36636 }
36637
36638
36639 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36640 PyObject *resultobj = 0;
36641 wxWindow *arg1 = (wxWindow *) 0 ;
36642 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36643 void *argp1 = 0 ;
36644 int res1 = 0 ;
36645 void *argp2 = 0 ;
36646 int res2 = 0 ;
36647 PyObject * obj0 = 0 ;
36648 PyObject * obj1 = 0 ;
36649 char * kwnames[] = {
36650 (char *) "self",(char *) "handler", NULL
36651 };
36652
36653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36655 if (!SWIG_IsOK(res1)) {
36656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36657 }
36658 arg1 = reinterpret_cast< wxWindow * >(argp1);
36659 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36660 if (!SWIG_IsOK(res2)) {
36661 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36662 }
36663 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36664 {
36665 PyThreadState* __tstate = wxPyBeginAllowThreads();
36666 (arg1)->SetEventHandler(arg2);
36667 wxPyEndAllowThreads(__tstate);
36668 if (PyErr_Occurred()) SWIG_fail;
36669 }
36670 resultobj = SWIG_Py_Void();
36671 return resultobj;
36672 fail:
36673 return NULL;
36674 }
36675
36676
36677 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36678 PyObject *resultobj = 0;
36679 wxWindow *arg1 = (wxWindow *) 0 ;
36680 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36681 void *argp1 = 0 ;
36682 int res1 = 0 ;
36683 void *argp2 = 0 ;
36684 int res2 = 0 ;
36685 PyObject * obj0 = 0 ;
36686 PyObject * obj1 = 0 ;
36687 char * kwnames[] = {
36688 (char *) "self",(char *) "handler", NULL
36689 };
36690
36691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36693 if (!SWIG_IsOK(res1)) {
36694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36695 }
36696 arg1 = reinterpret_cast< wxWindow * >(argp1);
36697 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36698 if (!SWIG_IsOK(res2)) {
36699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36700 }
36701 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36702 {
36703 PyThreadState* __tstate = wxPyBeginAllowThreads();
36704 (arg1)->PushEventHandler(arg2);
36705 wxPyEndAllowThreads(__tstate);
36706 if (PyErr_Occurred()) SWIG_fail;
36707 }
36708 resultobj = SWIG_Py_Void();
36709 return resultobj;
36710 fail:
36711 return NULL;
36712 }
36713
36714
36715 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36716 PyObject *resultobj = 0;
36717 wxWindow *arg1 = (wxWindow *) 0 ;
36718 bool arg2 = (bool) false ;
36719 wxEvtHandler *result = 0 ;
36720 void *argp1 = 0 ;
36721 int res1 = 0 ;
36722 bool val2 ;
36723 int ecode2 = 0 ;
36724 PyObject * obj0 = 0 ;
36725 PyObject * obj1 = 0 ;
36726 char * kwnames[] = {
36727 (char *) "self",(char *) "deleteHandler", NULL
36728 };
36729
36730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36732 if (!SWIG_IsOK(res1)) {
36733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36734 }
36735 arg1 = reinterpret_cast< wxWindow * >(argp1);
36736 if (obj1) {
36737 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36738 if (!SWIG_IsOK(ecode2)) {
36739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
36740 }
36741 arg2 = static_cast< bool >(val2);
36742 }
36743 {
36744 PyThreadState* __tstate = wxPyBeginAllowThreads();
36745 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
36746 wxPyEndAllowThreads(__tstate);
36747 if (PyErr_Occurred()) SWIG_fail;
36748 }
36749 {
36750 resultobj = wxPyMake_wxObject(result, 0);
36751 }
36752 return resultobj;
36753 fail:
36754 return NULL;
36755 }
36756
36757
36758 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36759 PyObject *resultobj = 0;
36760 wxWindow *arg1 = (wxWindow *) 0 ;
36761 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36762 bool result;
36763 void *argp1 = 0 ;
36764 int res1 = 0 ;
36765 void *argp2 = 0 ;
36766 int res2 = 0 ;
36767 PyObject * obj0 = 0 ;
36768 PyObject * obj1 = 0 ;
36769 char * kwnames[] = {
36770 (char *) "self",(char *) "handler", NULL
36771 };
36772
36773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36775 if (!SWIG_IsOK(res1)) {
36776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36777 }
36778 arg1 = reinterpret_cast< wxWindow * >(argp1);
36779 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36780 if (!SWIG_IsOK(res2)) {
36781 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36782 }
36783 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36784 {
36785 PyThreadState* __tstate = wxPyBeginAllowThreads();
36786 result = (bool)(arg1)->RemoveEventHandler(arg2);
36787 wxPyEndAllowThreads(__tstate);
36788 if (PyErr_Occurred()) SWIG_fail;
36789 }
36790 {
36791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36792 }
36793 return resultobj;
36794 fail:
36795 return NULL;
36796 }
36797
36798
36799 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36800 PyObject *resultobj = 0;
36801 wxWindow *arg1 = (wxWindow *) 0 ;
36802 wxValidator *arg2 = 0 ;
36803 void *argp1 = 0 ;
36804 int res1 = 0 ;
36805 void *argp2 = 0 ;
36806 int res2 = 0 ;
36807 PyObject * obj0 = 0 ;
36808 PyObject * obj1 = 0 ;
36809 char * kwnames[] = {
36810 (char *) "self",(char *) "validator", NULL
36811 };
36812
36813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
36814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36815 if (!SWIG_IsOK(res1)) {
36816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36817 }
36818 arg1 = reinterpret_cast< wxWindow * >(argp1);
36819 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
36820 if (!SWIG_IsOK(res2)) {
36821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36822 }
36823 if (!argp2) {
36824 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36825 }
36826 arg2 = reinterpret_cast< wxValidator * >(argp2);
36827 {
36828 PyThreadState* __tstate = wxPyBeginAllowThreads();
36829 (arg1)->SetValidator((wxValidator const &)*arg2);
36830 wxPyEndAllowThreads(__tstate);
36831 if (PyErr_Occurred()) SWIG_fail;
36832 }
36833 resultobj = SWIG_Py_Void();
36834 return resultobj;
36835 fail:
36836 return NULL;
36837 }
36838
36839
36840 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36841 PyObject *resultobj = 0;
36842 wxWindow *arg1 = (wxWindow *) 0 ;
36843 wxValidator *result = 0 ;
36844 void *argp1 = 0 ;
36845 int res1 = 0 ;
36846 PyObject *swig_obj[1] ;
36847
36848 if (!args) SWIG_fail;
36849 swig_obj[0] = args;
36850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36851 if (!SWIG_IsOK(res1)) {
36852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36853 }
36854 arg1 = reinterpret_cast< wxWindow * >(argp1);
36855 {
36856 PyThreadState* __tstate = wxPyBeginAllowThreads();
36857 result = (wxValidator *)(arg1)->GetValidator();
36858 wxPyEndAllowThreads(__tstate);
36859 if (PyErr_Occurred()) SWIG_fail;
36860 }
36861 {
36862 resultobj = wxPyMake_wxObject(result, (bool)0);
36863 }
36864 return resultobj;
36865 fail:
36866 return NULL;
36867 }
36868
36869
36870 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36871 PyObject *resultobj = 0;
36872 wxWindow *arg1 = (wxWindow *) 0 ;
36873 bool result;
36874 void *argp1 = 0 ;
36875 int res1 = 0 ;
36876 PyObject *swig_obj[1] ;
36877
36878 if (!args) SWIG_fail;
36879 swig_obj[0] = args;
36880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36881 if (!SWIG_IsOK(res1)) {
36882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
36883 }
36884 arg1 = reinterpret_cast< wxWindow * >(argp1);
36885 {
36886 PyThreadState* __tstate = wxPyBeginAllowThreads();
36887 result = (bool)(arg1)->Validate();
36888 wxPyEndAllowThreads(__tstate);
36889 if (PyErr_Occurred()) SWIG_fail;
36890 }
36891 {
36892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36893 }
36894 return resultobj;
36895 fail:
36896 return NULL;
36897 }
36898
36899
36900 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36901 PyObject *resultobj = 0;
36902 wxWindow *arg1 = (wxWindow *) 0 ;
36903 bool result;
36904 void *argp1 = 0 ;
36905 int res1 = 0 ;
36906 PyObject *swig_obj[1] ;
36907
36908 if (!args) SWIG_fail;
36909 swig_obj[0] = args;
36910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36911 if (!SWIG_IsOK(res1)) {
36912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36913 }
36914 arg1 = reinterpret_cast< wxWindow * >(argp1);
36915 {
36916 PyThreadState* __tstate = wxPyBeginAllowThreads();
36917 result = (bool)(arg1)->TransferDataToWindow();
36918 wxPyEndAllowThreads(__tstate);
36919 if (PyErr_Occurred()) SWIG_fail;
36920 }
36921 {
36922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36923 }
36924 return resultobj;
36925 fail:
36926 return NULL;
36927 }
36928
36929
36930 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36931 PyObject *resultobj = 0;
36932 wxWindow *arg1 = (wxWindow *) 0 ;
36933 bool result;
36934 void *argp1 = 0 ;
36935 int res1 = 0 ;
36936 PyObject *swig_obj[1] ;
36937
36938 if (!args) SWIG_fail;
36939 swig_obj[0] = args;
36940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36941 if (!SWIG_IsOK(res1)) {
36942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36943 }
36944 arg1 = reinterpret_cast< wxWindow * >(argp1);
36945 {
36946 PyThreadState* __tstate = wxPyBeginAllowThreads();
36947 result = (bool)(arg1)->TransferDataFromWindow();
36948 wxPyEndAllowThreads(__tstate);
36949 if (PyErr_Occurred()) SWIG_fail;
36950 }
36951 {
36952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36953 }
36954 return resultobj;
36955 fail:
36956 return NULL;
36957 }
36958
36959
36960 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36961 PyObject *resultobj = 0;
36962 wxWindow *arg1 = (wxWindow *) 0 ;
36963 void *argp1 = 0 ;
36964 int res1 = 0 ;
36965 PyObject *swig_obj[1] ;
36966
36967 if (!args) SWIG_fail;
36968 swig_obj[0] = args;
36969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36970 if (!SWIG_IsOK(res1)) {
36971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
36972 }
36973 arg1 = reinterpret_cast< wxWindow * >(argp1);
36974 {
36975 PyThreadState* __tstate = wxPyBeginAllowThreads();
36976 (arg1)->InitDialog();
36977 wxPyEndAllowThreads(__tstate);
36978 if (PyErr_Occurred()) SWIG_fail;
36979 }
36980 resultobj = SWIG_Py_Void();
36981 return resultobj;
36982 fail:
36983 return NULL;
36984 }
36985
36986
36987 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36988 PyObject *resultobj = 0;
36989 wxWindow *arg1 = (wxWindow *) 0 ;
36990 wxAcceleratorTable *arg2 = 0 ;
36991 void *argp1 = 0 ;
36992 int res1 = 0 ;
36993 void *argp2 = 0 ;
36994 int res2 = 0 ;
36995 PyObject * obj0 = 0 ;
36996 PyObject * obj1 = 0 ;
36997 char * kwnames[] = {
36998 (char *) "self",(char *) "accel", NULL
36999 };
37000
37001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37003 if (!SWIG_IsOK(res1)) {
37004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37005 }
37006 arg1 = reinterpret_cast< wxWindow * >(argp1);
37007 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37008 if (!SWIG_IsOK(res2)) {
37009 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37010 }
37011 if (!argp2) {
37012 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37013 }
37014 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37015 {
37016 PyThreadState* __tstate = wxPyBeginAllowThreads();
37017 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37018 wxPyEndAllowThreads(__tstate);
37019 if (PyErr_Occurred()) SWIG_fail;
37020 }
37021 resultobj = SWIG_Py_Void();
37022 return resultobj;
37023 fail:
37024 return NULL;
37025 }
37026
37027
37028 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37029 PyObject *resultobj = 0;
37030 wxWindow *arg1 = (wxWindow *) 0 ;
37031 wxAcceleratorTable *result = 0 ;
37032 void *argp1 = 0 ;
37033 int res1 = 0 ;
37034 PyObject *swig_obj[1] ;
37035
37036 if (!args) SWIG_fail;
37037 swig_obj[0] = args;
37038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37039 if (!SWIG_IsOK(res1)) {
37040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37041 }
37042 arg1 = reinterpret_cast< wxWindow * >(argp1);
37043 {
37044 PyThreadState* __tstate = wxPyBeginAllowThreads();
37045 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37046 wxPyEndAllowThreads(__tstate);
37047 if (PyErr_Occurred()) SWIG_fail;
37048 }
37049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37050 return resultobj;
37051 fail:
37052 return NULL;
37053 }
37054
37055
37056 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37057 PyObject *resultobj = 0;
37058 wxWindow *arg1 = (wxWindow *) 0 ;
37059 int arg2 ;
37060 int arg3 ;
37061 int arg4 ;
37062 bool result;
37063 void *argp1 = 0 ;
37064 int res1 = 0 ;
37065 int val2 ;
37066 int ecode2 = 0 ;
37067 int val3 ;
37068 int ecode3 = 0 ;
37069 int val4 ;
37070 int ecode4 = 0 ;
37071 PyObject * obj0 = 0 ;
37072 PyObject * obj1 = 0 ;
37073 PyObject * obj2 = 0 ;
37074 PyObject * obj3 = 0 ;
37075 char * kwnames[] = {
37076 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37077 };
37078
37079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37081 if (!SWIG_IsOK(res1)) {
37082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37083 }
37084 arg1 = reinterpret_cast< wxWindow * >(argp1);
37085 ecode2 = SWIG_AsVal_int(obj1, &val2);
37086 if (!SWIG_IsOK(ecode2)) {
37087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37088 }
37089 arg2 = static_cast< int >(val2);
37090 ecode3 = SWIG_AsVal_int(obj2, &val3);
37091 if (!SWIG_IsOK(ecode3)) {
37092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37093 }
37094 arg3 = static_cast< int >(val3);
37095 ecode4 = SWIG_AsVal_int(obj3, &val4);
37096 if (!SWIG_IsOK(ecode4)) {
37097 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37098 }
37099 arg4 = static_cast< int >(val4);
37100 {
37101 PyThreadState* __tstate = wxPyBeginAllowThreads();
37102 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37103 wxPyEndAllowThreads(__tstate);
37104 if (PyErr_Occurred()) SWIG_fail;
37105 }
37106 {
37107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37108 }
37109 return resultobj;
37110 fail:
37111 return NULL;
37112 }
37113
37114
37115 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37116 PyObject *resultobj = 0;
37117 wxWindow *arg1 = (wxWindow *) 0 ;
37118 int arg2 ;
37119 bool result;
37120 void *argp1 = 0 ;
37121 int res1 = 0 ;
37122 int val2 ;
37123 int ecode2 = 0 ;
37124 PyObject * obj0 = 0 ;
37125 PyObject * obj1 = 0 ;
37126 char * kwnames[] = {
37127 (char *) "self",(char *) "hotkeyId", NULL
37128 };
37129
37130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37132 if (!SWIG_IsOK(res1)) {
37133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37134 }
37135 arg1 = reinterpret_cast< wxWindow * >(argp1);
37136 ecode2 = SWIG_AsVal_int(obj1, &val2);
37137 if (!SWIG_IsOK(ecode2)) {
37138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37139 }
37140 arg2 = static_cast< int >(val2);
37141 {
37142 PyThreadState* __tstate = wxPyBeginAllowThreads();
37143 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37144 wxPyEndAllowThreads(__tstate);
37145 if (PyErr_Occurred()) SWIG_fail;
37146 }
37147 {
37148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37149 }
37150 return resultobj;
37151 fail:
37152 return NULL;
37153 }
37154
37155
37156 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37157 PyObject *resultobj = 0;
37158 wxWindow *arg1 = (wxWindow *) 0 ;
37159 wxPoint *arg2 = 0 ;
37160 wxPoint result;
37161 void *argp1 = 0 ;
37162 int res1 = 0 ;
37163 wxPoint temp2 ;
37164 PyObject * obj0 = 0 ;
37165 PyObject * obj1 = 0 ;
37166 char * kwnames[] = {
37167 (char *) "self",(char *) "pt", NULL
37168 };
37169
37170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37172 if (!SWIG_IsOK(res1)) {
37173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37174 }
37175 arg1 = reinterpret_cast< wxWindow * >(argp1);
37176 {
37177 arg2 = &temp2;
37178 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37179 }
37180 {
37181 PyThreadState* __tstate = wxPyBeginAllowThreads();
37182 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37183 wxPyEndAllowThreads(__tstate);
37184 if (PyErr_Occurred()) SWIG_fail;
37185 }
37186 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37187 return resultobj;
37188 fail:
37189 return NULL;
37190 }
37191
37192
37193 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37194 PyObject *resultobj = 0;
37195 wxWindow *arg1 = (wxWindow *) 0 ;
37196 wxSize *arg2 = 0 ;
37197 wxSize result;
37198 void *argp1 = 0 ;
37199 int res1 = 0 ;
37200 wxSize temp2 ;
37201 PyObject * obj0 = 0 ;
37202 PyObject * obj1 = 0 ;
37203 char * kwnames[] = {
37204 (char *) "self",(char *) "sz", NULL
37205 };
37206
37207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37209 if (!SWIG_IsOK(res1)) {
37210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37211 }
37212 arg1 = reinterpret_cast< wxWindow * >(argp1);
37213 {
37214 arg2 = &temp2;
37215 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37216 }
37217 {
37218 PyThreadState* __tstate = wxPyBeginAllowThreads();
37219 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37220 wxPyEndAllowThreads(__tstate);
37221 if (PyErr_Occurred()) SWIG_fail;
37222 }
37223 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37224 return resultobj;
37225 fail:
37226 return NULL;
37227 }
37228
37229
37230 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37231 PyObject *resultobj = 0;
37232 wxWindow *arg1 = (wxWindow *) 0 ;
37233 wxPoint *arg2 = 0 ;
37234 wxPoint result;
37235 void *argp1 = 0 ;
37236 int res1 = 0 ;
37237 wxPoint temp2 ;
37238 PyObject * obj0 = 0 ;
37239 PyObject * obj1 = 0 ;
37240 char * kwnames[] = {
37241 (char *) "self",(char *) "pt", NULL
37242 };
37243
37244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37246 if (!SWIG_IsOK(res1)) {
37247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37248 }
37249 arg1 = reinterpret_cast< wxWindow * >(argp1);
37250 {
37251 arg2 = &temp2;
37252 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37253 }
37254 {
37255 PyThreadState* __tstate = wxPyBeginAllowThreads();
37256 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37257 wxPyEndAllowThreads(__tstate);
37258 if (PyErr_Occurred()) SWIG_fail;
37259 }
37260 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37261 return resultobj;
37262 fail:
37263 return NULL;
37264 }
37265
37266
37267 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37268 PyObject *resultobj = 0;
37269 wxWindow *arg1 = (wxWindow *) 0 ;
37270 wxSize *arg2 = 0 ;
37271 wxSize result;
37272 void *argp1 = 0 ;
37273 int res1 = 0 ;
37274 wxSize temp2 ;
37275 PyObject * obj0 = 0 ;
37276 PyObject * obj1 = 0 ;
37277 char * kwnames[] = {
37278 (char *) "self",(char *) "sz", NULL
37279 };
37280
37281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37283 if (!SWIG_IsOK(res1)) {
37284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37285 }
37286 arg1 = reinterpret_cast< wxWindow * >(argp1);
37287 {
37288 arg2 = &temp2;
37289 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37290 }
37291 {
37292 PyThreadState* __tstate = wxPyBeginAllowThreads();
37293 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37294 wxPyEndAllowThreads(__tstate);
37295 if (PyErr_Occurred()) SWIG_fail;
37296 }
37297 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37298 return resultobj;
37299 fail:
37300 return NULL;
37301 }
37302
37303
37304 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37305 PyObject *resultobj = 0;
37306 wxWindow *arg1 = (wxWindow *) 0 ;
37307 wxPoint *arg2 = 0 ;
37308 wxPoint result;
37309 void *argp1 = 0 ;
37310 int res1 = 0 ;
37311 wxPoint temp2 ;
37312 PyObject * obj0 = 0 ;
37313 PyObject * obj1 = 0 ;
37314 char * kwnames[] = {
37315 (char *) "self",(char *) "pt", NULL
37316 };
37317
37318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37320 if (!SWIG_IsOK(res1)) {
37321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37322 }
37323 arg1 = reinterpret_cast< wxWindow * >(argp1);
37324 {
37325 arg2 = &temp2;
37326 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37327 }
37328 {
37329 PyThreadState* __tstate = wxPyBeginAllowThreads();
37330 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37331 wxPyEndAllowThreads(__tstate);
37332 if (PyErr_Occurred()) SWIG_fail;
37333 }
37334 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37335 return resultobj;
37336 fail:
37337 return NULL;
37338 }
37339
37340
37341 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37342 PyObject *resultobj = 0;
37343 wxWindow *arg1 = (wxWindow *) 0 ;
37344 wxSize *arg2 = 0 ;
37345 wxSize result;
37346 void *argp1 = 0 ;
37347 int res1 = 0 ;
37348 wxSize temp2 ;
37349 PyObject * obj0 = 0 ;
37350 PyObject * obj1 = 0 ;
37351 char * kwnames[] = {
37352 (char *) "self",(char *) "sz", NULL
37353 };
37354
37355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37357 if (!SWIG_IsOK(res1)) {
37358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37359 }
37360 arg1 = reinterpret_cast< wxWindow * >(argp1);
37361 {
37362 arg2 = &temp2;
37363 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37364 }
37365 {
37366 PyThreadState* __tstate = wxPyBeginAllowThreads();
37367 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37368 wxPyEndAllowThreads(__tstate);
37369 if (PyErr_Occurred()) SWIG_fail;
37370 }
37371 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37372 return resultobj;
37373 fail:
37374 return NULL;
37375 }
37376
37377
37378 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37379 PyObject *resultobj = 0;
37380 wxWindow *arg1 = (wxWindow *) 0 ;
37381 int arg2 ;
37382 int arg3 ;
37383 void *argp1 = 0 ;
37384 int res1 = 0 ;
37385 int val2 ;
37386 int ecode2 = 0 ;
37387 int val3 ;
37388 int ecode3 = 0 ;
37389 PyObject * obj0 = 0 ;
37390 PyObject * obj1 = 0 ;
37391 PyObject * obj2 = 0 ;
37392 char * kwnames[] = {
37393 (char *) "self",(char *) "x",(char *) "y", NULL
37394 };
37395
37396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37398 if (!SWIG_IsOK(res1)) {
37399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37400 }
37401 arg1 = reinterpret_cast< wxWindow * >(argp1);
37402 ecode2 = SWIG_AsVal_int(obj1, &val2);
37403 if (!SWIG_IsOK(ecode2)) {
37404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37405 }
37406 arg2 = static_cast< int >(val2);
37407 ecode3 = SWIG_AsVal_int(obj2, &val3);
37408 if (!SWIG_IsOK(ecode3)) {
37409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37410 }
37411 arg3 = static_cast< int >(val3);
37412 {
37413 PyThreadState* __tstate = wxPyBeginAllowThreads();
37414 (arg1)->WarpPointer(arg2,arg3);
37415 wxPyEndAllowThreads(__tstate);
37416 if (PyErr_Occurred()) SWIG_fail;
37417 }
37418 resultobj = SWIG_Py_Void();
37419 return resultobj;
37420 fail:
37421 return NULL;
37422 }
37423
37424
37425 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37426 PyObject *resultobj = 0;
37427 wxWindow *arg1 = (wxWindow *) 0 ;
37428 void *argp1 = 0 ;
37429 int res1 = 0 ;
37430 PyObject *swig_obj[1] ;
37431
37432 if (!args) SWIG_fail;
37433 swig_obj[0] = args;
37434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37435 if (!SWIG_IsOK(res1)) {
37436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37437 }
37438 arg1 = reinterpret_cast< wxWindow * >(argp1);
37439 {
37440 PyThreadState* __tstate = wxPyBeginAllowThreads();
37441 (arg1)->CaptureMouse();
37442 wxPyEndAllowThreads(__tstate);
37443 if (PyErr_Occurred()) SWIG_fail;
37444 }
37445 resultobj = SWIG_Py_Void();
37446 return resultobj;
37447 fail:
37448 return NULL;
37449 }
37450
37451
37452 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37453 PyObject *resultobj = 0;
37454 wxWindow *arg1 = (wxWindow *) 0 ;
37455 void *argp1 = 0 ;
37456 int res1 = 0 ;
37457 PyObject *swig_obj[1] ;
37458
37459 if (!args) SWIG_fail;
37460 swig_obj[0] = args;
37461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37462 if (!SWIG_IsOK(res1)) {
37463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37464 }
37465 arg1 = reinterpret_cast< wxWindow * >(argp1);
37466 {
37467 PyThreadState* __tstate = wxPyBeginAllowThreads();
37468 (arg1)->ReleaseMouse();
37469 wxPyEndAllowThreads(__tstate);
37470 if (PyErr_Occurred()) SWIG_fail;
37471 }
37472 resultobj = SWIG_Py_Void();
37473 return resultobj;
37474 fail:
37475 return NULL;
37476 }
37477
37478
37479 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37480 PyObject *resultobj = 0;
37481 wxWindow *result = 0 ;
37482
37483 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37484 {
37485 if (!wxPyCheckForApp()) SWIG_fail;
37486 PyThreadState* __tstate = wxPyBeginAllowThreads();
37487 result = (wxWindow *)wxWindow::GetCapture();
37488 wxPyEndAllowThreads(__tstate);
37489 if (PyErr_Occurred()) SWIG_fail;
37490 }
37491 {
37492 resultobj = wxPyMake_wxObject(result, 0);
37493 }
37494 return resultobj;
37495 fail:
37496 return NULL;
37497 }
37498
37499
37500 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37501 PyObject *resultobj = 0;
37502 wxWindow *arg1 = (wxWindow *) 0 ;
37503 bool result;
37504 void *argp1 = 0 ;
37505 int res1 = 0 ;
37506 PyObject *swig_obj[1] ;
37507
37508 if (!args) SWIG_fail;
37509 swig_obj[0] = args;
37510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37511 if (!SWIG_IsOK(res1)) {
37512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37513 }
37514 arg1 = reinterpret_cast< wxWindow * >(argp1);
37515 {
37516 PyThreadState* __tstate = wxPyBeginAllowThreads();
37517 result = (bool)((wxWindow const *)arg1)->HasCapture();
37518 wxPyEndAllowThreads(__tstate);
37519 if (PyErr_Occurred()) SWIG_fail;
37520 }
37521 {
37522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37523 }
37524 return resultobj;
37525 fail:
37526 return NULL;
37527 }
37528
37529
37530 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37531 PyObject *resultobj = 0;
37532 wxWindow *arg1 = (wxWindow *) 0 ;
37533 bool arg2 = (bool) true ;
37534 wxRect *arg3 = (wxRect *) NULL ;
37535 void *argp1 = 0 ;
37536 int res1 = 0 ;
37537 bool val2 ;
37538 int ecode2 = 0 ;
37539 void *argp3 = 0 ;
37540 int res3 = 0 ;
37541 PyObject * obj0 = 0 ;
37542 PyObject * obj1 = 0 ;
37543 PyObject * obj2 = 0 ;
37544 char * kwnames[] = {
37545 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37546 };
37547
37548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37550 if (!SWIG_IsOK(res1)) {
37551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37552 }
37553 arg1 = reinterpret_cast< wxWindow * >(argp1);
37554 if (obj1) {
37555 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37556 if (!SWIG_IsOK(ecode2)) {
37557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37558 }
37559 arg2 = static_cast< bool >(val2);
37560 }
37561 if (obj2) {
37562 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37563 if (!SWIG_IsOK(res3)) {
37564 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37565 }
37566 arg3 = reinterpret_cast< wxRect * >(argp3);
37567 }
37568 {
37569 PyThreadState* __tstate = wxPyBeginAllowThreads();
37570 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37571 wxPyEndAllowThreads(__tstate);
37572 if (PyErr_Occurred()) SWIG_fail;
37573 }
37574 resultobj = SWIG_Py_Void();
37575 return resultobj;
37576 fail:
37577 return NULL;
37578 }
37579
37580
37581 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37582 PyObject *resultobj = 0;
37583 wxWindow *arg1 = (wxWindow *) 0 ;
37584 wxRect *arg2 = 0 ;
37585 bool arg3 = (bool) true ;
37586 void *argp1 = 0 ;
37587 int res1 = 0 ;
37588 wxRect temp2 ;
37589 bool val3 ;
37590 int ecode3 = 0 ;
37591 PyObject * obj0 = 0 ;
37592 PyObject * obj1 = 0 ;
37593 PyObject * obj2 = 0 ;
37594 char * kwnames[] = {
37595 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37596 };
37597
37598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37600 if (!SWIG_IsOK(res1)) {
37601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37602 }
37603 arg1 = reinterpret_cast< wxWindow * >(argp1);
37604 {
37605 arg2 = &temp2;
37606 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37607 }
37608 if (obj2) {
37609 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37610 if (!SWIG_IsOK(ecode3)) {
37611 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37612 }
37613 arg3 = static_cast< bool >(val3);
37614 }
37615 {
37616 PyThreadState* __tstate = wxPyBeginAllowThreads();
37617 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37618 wxPyEndAllowThreads(__tstate);
37619 if (PyErr_Occurred()) SWIG_fail;
37620 }
37621 resultobj = SWIG_Py_Void();
37622 return resultobj;
37623 fail:
37624 return NULL;
37625 }
37626
37627
37628 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37629 PyObject *resultobj = 0;
37630 wxWindow *arg1 = (wxWindow *) 0 ;
37631 void *argp1 = 0 ;
37632 int res1 = 0 ;
37633 PyObject *swig_obj[1] ;
37634
37635 if (!args) SWIG_fail;
37636 swig_obj[0] = args;
37637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37638 if (!SWIG_IsOK(res1)) {
37639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
37640 }
37641 arg1 = reinterpret_cast< wxWindow * >(argp1);
37642 {
37643 PyThreadState* __tstate = wxPyBeginAllowThreads();
37644 (arg1)->Update();
37645 wxPyEndAllowThreads(__tstate);
37646 if (PyErr_Occurred()) SWIG_fail;
37647 }
37648 resultobj = SWIG_Py_Void();
37649 return resultobj;
37650 fail:
37651 return NULL;
37652 }
37653
37654
37655 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37656 PyObject *resultobj = 0;
37657 wxWindow *arg1 = (wxWindow *) 0 ;
37658 void *argp1 = 0 ;
37659 int res1 = 0 ;
37660 PyObject *swig_obj[1] ;
37661
37662 if (!args) SWIG_fail;
37663 swig_obj[0] = args;
37664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37665 if (!SWIG_IsOK(res1)) {
37666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
37667 }
37668 arg1 = reinterpret_cast< wxWindow * >(argp1);
37669 {
37670 PyThreadState* __tstate = wxPyBeginAllowThreads();
37671 (arg1)->ClearBackground();
37672 wxPyEndAllowThreads(__tstate);
37673 if (PyErr_Occurred()) SWIG_fail;
37674 }
37675 resultobj = SWIG_Py_Void();
37676 return resultobj;
37677 fail:
37678 return NULL;
37679 }
37680
37681
37682 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37683 PyObject *resultobj = 0;
37684 wxWindow *arg1 = (wxWindow *) 0 ;
37685 void *argp1 = 0 ;
37686 int res1 = 0 ;
37687 PyObject *swig_obj[1] ;
37688
37689 if (!args) SWIG_fail;
37690 swig_obj[0] = args;
37691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37692 if (!SWIG_IsOK(res1)) {
37693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
37694 }
37695 arg1 = reinterpret_cast< wxWindow * >(argp1);
37696 {
37697 PyThreadState* __tstate = wxPyBeginAllowThreads();
37698 (arg1)->Freeze();
37699 wxPyEndAllowThreads(__tstate);
37700 if (PyErr_Occurred()) SWIG_fail;
37701 }
37702 resultobj = SWIG_Py_Void();
37703 return resultobj;
37704 fail:
37705 return NULL;
37706 }
37707
37708
37709 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37710 PyObject *resultobj = 0;
37711 wxWindow *arg1 = (wxWindow *) 0 ;
37712 bool result;
37713 void *argp1 = 0 ;
37714 int res1 = 0 ;
37715 PyObject *swig_obj[1] ;
37716
37717 if (!args) SWIG_fail;
37718 swig_obj[0] = args;
37719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37720 if (!SWIG_IsOK(res1)) {
37721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37722 }
37723 arg1 = reinterpret_cast< wxWindow * >(argp1);
37724 {
37725 PyThreadState* __tstate = wxPyBeginAllowThreads();
37726 result = (bool)((wxWindow const *)arg1)->IsFrozen();
37727 wxPyEndAllowThreads(__tstate);
37728 if (PyErr_Occurred()) SWIG_fail;
37729 }
37730 {
37731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37732 }
37733 return resultobj;
37734 fail:
37735 return NULL;
37736 }
37737
37738
37739 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37740 PyObject *resultobj = 0;
37741 wxWindow *arg1 = (wxWindow *) 0 ;
37742 void *argp1 = 0 ;
37743 int res1 = 0 ;
37744 PyObject *swig_obj[1] ;
37745
37746 if (!args) SWIG_fail;
37747 swig_obj[0] = args;
37748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37749 if (!SWIG_IsOK(res1)) {
37750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
37751 }
37752 arg1 = reinterpret_cast< wxWindow * >(argp1);
37753 {
37754 PyThreadState* __tstate = wxPyBeginAllowThreads();
37755 (arg1)->Thaw();
37756 wxPyEndAllowThreads(__tstate);
37757 if (PyErr_Occurred()) SWIG_fail;
37758 }
37759 resultobj = SWIG_Py_Void();
37760 return resultobj;
37761 fail:
37762 return NULL;
37763 }
37764
37765
37766 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37767 PyObject *resultobj = 0;
37768 wxWindow *arg1 = (wxWindow *) 0 ;
37769 wxDC *arg2 = 0 ;
37770 void *argp1 = 0 ;
37771 int res1 = 0 ;
37772 void *argp2 = 0 ;
37773 int res2 = 0 ;
37774 PyObject * obj0 = 0 ;
37775 PyObject * obj1 = 0 ;
37776 char * kwnames[] = {
37777 (char *) "self",(char *) "dc", NULL
37778 };
37779
37780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
37781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37782 if (!SWIG_IsOK(res1)) {
37783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
37784 }
37785 arg1 = reinterpret_cast< wxWindow * >(argp1);
37786 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
37787 if (!SWIG_IsOK(res2)) {
37788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37789 }
37790 if (!argp2) {
37791 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37792 }
37793 arg2 = reinterpret_cast< wxDC * >(argp2);
37794 {
37795 PyThreadState* __tstate = wxPyBeginAllowThreads();
37796 (arg1)->PrepareDC(*arg2);
37797 wxPyEndAllowThreads(__tstate);
37798 if (PyErr_Occurred()) SWIG_fail;
37799 }
37800 resultobj = SWIG_Py_Void();
37801 return resultobj;
37802 fail:
37803 return NULL;
37804 }
37805
37806
37807 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37808 PyObject *resultobj = 0;
37809 wxWindow *arg1 = (wxWindow *) 0 ;
37810 bool result;
37811 void *argp1 = 0 ;
37812 int res1 = 0 ;
37813 PyObject *swig_obj[1] ;
37814
37815 if (!args) SWIG_fail;
37816 swig_obj[0] = args;
37817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37818 if (!SWIG_IsOK(res1)) {
37819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
37820 }
37821 arg1 = reinterpret_cast< wxWindow * >(argp1);
37822 {
37823 PyThreadState* __tstate = wxPyBeginAllowThreads();
37824 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
37825 wxPyEndAllowThreads(__tstate);
37826 if (PyErr_Occurred()) SWIG_fail;
37827 }
37828 {
37829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37830 }
37831 return resultobj;
37832 fail:
37833 return NULL;
37834 }
37835
37836
37837 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37838 PyObject *resultobj = 0;
37839 wxWindow *arg1 = (wxWindow *) 0 ;
37840 wxRegion *result = 0 ;
37841 void *argp1 = 0 ;
37842 int res1 = 0 ;
37843 PyObject *swig_obj[1] ;
37844
37845 if (!args) SWIG_fail;
37846 swig_obj[0] = args;
37847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37848 if (!SWIG_IsOK(res1)) {
37849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
37850 }
37851 arg1 = reinterpret_cast< wxWindow * >(argp1);
37852 {
37853 PyThreadState* __tstate = wxPyBeginAllowThreads();
37854 {
37855 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
37856 result = (wxRegion *) &_result_ref;
37857 }
37858 wxPyEndAllowThreads(__tstate);
37859 if (PyErr_Occurred()) SWIG_fail;
37860 }
37861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
37862 return resultobj;
37863 fail:
37864 return NULL;
37865 }
37866
37867
37868 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37869 PyObject *resultobj = 0;
37870 wxWindow *arg1 = (wxWindow *) 0 ;
37871 wxRect result;
37872 void *argp1 = 0 ;
37873 int res1 = 0 ;
37874 PyObject *swig_obj[1] ;
37875
37876 if (!args) SWIG_fail;
37877 swig_obj[0] = args;
37878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37879 if (!SWIG_IsOK(res1)) {
37880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
37881 }
37882 arg1 = reinterpret_cast< wxWindow * >(argp1);
37883 {
37884 PyThreadState* __tstate = wxPyBeginAllowThreads();
37885 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
37886 wxPyEndAllowThreads(__tstate);
37887 if (PyErr_Occurred()) SWIG_fail;
37888 }
37889 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
37890 return resultobj;
37891 fail:
37892 return NULL;
37893 }
37894
37895
37896 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37897 PyObject *resultobj = 0;
37898 wxWindow *arg1 = (wxWindow *) 0 ;
37899 int arg2 ;
37900 int arg3 ;
37901 int arg4 = (int) 1 ;
37902 int arg5 = (int) 1 ;
37903 bool result;
37904 void *argp1 = 0 ;
37905 int res1 = 0 ;
37906 int val2 ;
37907 int ecode2 = 0 ;
37908 int val3 ;
37909 int ecode3 = 0 ;
37910 int val4 ;
37911 int ecode4 = 0 ;
37912 int val5 ;
37913 int ecode5 = 0 ;
37914 PyObject * obj0 = 0 ;
37915 PyObject * obj1 = 0 ;
37916 PyObject * obj2 = 0 ;
37917 PyObject * obj3 = 0 ;
37918 PyObject * obj4 = 0 ;
37919 char * kwnames[] = {
37920 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
37921 };
37922
37923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37925 if (!SWIG_IsOK(res1)) {
37926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
37927 }
37928 arg1 = reinterpret_cast< wxWindow * >(argp1);
37929 ecode2 = SWIG_AsVal_int(obj1, &val2);
37930 if (!SWIG_IsOK(ecode2)) {
37931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
37932 }
37933 arg2 = static_cast< int >(val2);
37934 ecode3 = SWIG_AsVal_int(obj2, &val3);
37935 if (!SWIG_IsOK(ecode3)) {
37936 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
37937 }
37938 arg3 = static_cast< int >(val3);
37939 if (obj3) {
37940 ecode4 = SWIG_AsVal_int(obj3, &val4);
37941 if (!SWIG_IsOK(ecode4)) {
37942 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
37943 }
37944 arg4 = static_cast< int >(val4);
37945 }
37946 if (obj4) {
37947 ecode5 = SWIG_AsVal_int(obj4, &val5);
37948 if (!SWIG_IsOK(ecode5)) {
37949 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
37950 }
37951 arg5 = static_cast< int >(val5);
37952 }
37953 {
37954 PyThreadState* __tstate = wxPyBeginAllowThreads();
37955 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
37956 wxPyEndAllowThreads(__tstate);
37957 if (PyErr_Occurred()) SWIG_fail;
37958 }
37959 {
37960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37961 }
37962 return resultobj;
37963 fail:
37964 return NULL;
37965 }
37966
37967
37968 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37969 PyObject *resultobj = 0;
37970 wxWindow *arg1 = (wxWindow *) 0 ;
37971 wxPoint *arg2 = 0 ;
37972 bool result;
37973 void *argp1 = 0 ;
37974 int res1 = 0 ;
37975 wxPoint temp2 ;
37976 PyObject * obj0 = 0 ;
37977 PyObject * obj1 = 0 ;
37978 char * kwnames[] = {
37979 (char *) "self",(char *) "pt", NULL
37980 };
37981
37982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
37983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37984 if (!SWIG_IsOK(res1)) {
37985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37986 }
37987 arg1 = reinterpret_cast< wxWindow * >(argp1);
37988 {
37989 arg2 = &temp2;
37990 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37991 }
37992 {
37993 PyThreadState* __tstate = wxPyBeginAllowThreads();
37994 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
37995 wxPyEndAllowThreads(__tstate);
37996 if (PyErr_Occurred()) SWIG_fail;
37997 }
37998 {
37999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38000 }
38001 return resultobj;
38002 fail:
38003 return NULL;
38004 }
38005
38006
38007 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38008 PyObject *resultobj = 0;
38009 wxWindow *arg1 = (wxWindow *) 0 ;
38010 wxRect *arg2 = 0 ;
38011 bool result;
38012 void *argp1 = 0 ;
38013 int res1 = 0 ;
38014 wxRect temp2 ;
38015 PyObject * obj0 = 0 ;
38016 PyObject * obj1 = 0 ;
38017 char * kwnames[] = {
38018 (char *) "self",(char *) "rect", NULL
38019 };
38020
38021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38023 if (!SWIG_IsOK(res1)) {
38024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38025 }
38026 arg1 = reinterpret_cast< wxWindow * >(argp1);
38027 {
38028 arg2 = &temp2;
38029 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38030 }
38031 {
38032 PyThreadState* __tstate = wxPyBeginAllowThreads();
38033 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38034 wxPyEndAllowThreads(__tstate);
38035 if (PyErr_Occurred()) SWIG_fail;
38036 }
38037 {
38038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38039 }
38040 return resultobj;
38041 fail:
38042 return NULL;
38043 }
38044
38045
38046 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38047 PyObject *resultobj = 0;
38048 wxWindow *arg1 = (wxWindow *) 0 ;
38049 SwigValueWrapper<wxVisualAttributes > result;
38050 void *argp1 = 0 ;
38051 int res1 = 0 ;
38052 PyObject *swig_obj[1] ;
38053
38054 if (!args) SWIG_fail;
38055 swig_obj[0] = args;
38056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38057 if (!SWIG_IsOK(res1)) {
38058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38059 }
38060 arg1 = reinterpret_cast< wxWindow * >(argp1);
38061 {
38062 PyThreadState* __tstate = wxPyBeginAllowThreads();
38063 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38064 wxPyEndAllowThreads(__tstate);
38065 if (PyErr_Occurred()) SWIG_fail;
38066 }
38067 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38068 return resultobj;
38069 fail:
38070 return NULL;
38071 }
38072
38073
38074 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38075 PyObject *resultobj = 0;
38076 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38077 SwigValueWrapper<wxVisualAttributes > result;
38078 int val1 ;
38079 int ecode1 = 0 ;
38080 PyObject * obj0 = 0 ;
38081 char * kwnames[] = {
38082 (char *) "variant", NULL
38083 };
38084
38085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38086 if (obj0) {
38087 ecode1 = SWIG_AsVal_int(obj0, &val1);
38088 if (!SWIG_IsOK(ecode1)) {
38089 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38090 }
38091 arg1 = static_cast< wxWindowVariant >(val1);
38092 }
38093 {
38094 if (!wxPyCheckForApp()) SWIG_fail;
38095 PyThreadState* __tstate = wxPyBeginAllowThreads();
38096 result = wxWindow::GetClassDefaultAttributes(arg1);
38097 wxPyEndAllowThreads(__tstate);
38098 if (PyErr_Occurred()) SWIG_fail;
38099 }
38100 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38101 return resultobj;
38102 fail:
38103 return NULL;
38104 }
38105
38106
38107 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38108 PyObject *resultobj = 0;
38109 wxWindow *arg1 = (wxWindow *) 0 ;
38110 wxColour *arg2 = 0 ;
38111 bool result;
38112 void *argp1 = 0 ;
38113 int res1 = 0 ;
38114 wxColour temp2 ;
38115 PyObject * obj0 = 0 ;
38116 PyObject * obj1 = 0 ;
38117 char * kwnames[] = {
38118 (char *) "self",(char *) "colour", NULL
38119 };
38120
38121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38123 if (!SWIG_IsOK(res1)) {
38124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38125 }
38126 arg1 = reinterpret_cast< wxWindow * >(argp1);
38127 {
38128 arg2 = &temp2;
38129 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38130 }
38131 {
38132 PyThreadState* __tstate = wxPyBeginAllowThreads();
38133 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38134 wxPyEndAllowThreads(__tstate);
38135 if (PyErr_Occurred()) SWIG_fail;
38136 }
38137 {
38138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38139 }
38140 return resultobj;
38141 fail:
38142 return NULL;
38143 }
38144
38145
38146 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38147 PyObject *resultobj = 0;
38148 wxWindow *arg1 = (wxWindow *) 0 ;
38149 wxColour *arg2 = 0 ;
38150 void *argp1 = 0 ;
38151 int res1 = 0 ;
38152 wxColour temp2 ;
38153 PyObject * obj0 = 0 ;
38154 PyObject * obj1 = 0 ;
38155 char * kwnames[] = {
38156 (char *) "self",(char *) "colour", NULL
38157 };
38158
38159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38161 if (!SWIG_IsOK(res1)) {
38162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38163 }
38164 arg1 = reinterpret_cast< wxWindow * >(argp1);
38165 {
38166 arg2 = &temp2;
38167 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38168 }
38169 {
38170 PyThreadState* __tstate = wxPyBeginAllowThreads();
38171 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38172 wxPyEndAllowThreads(__tstate);
38173 if (PyErr_Occurred()) SWIG_fail;
38174 }
38175 resultobj = SWIG_Py_Void();
38176 return resultobj;
38177 fail:
38178 return NULL;
38179 }
38180
38181
38182 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38183 PyObject *resultobj = 0;
38184 wxWindow *arg1 = (wxWindow *) 0 ;
38185 wxColour *arg2 = 0 ;
38186 bool result;
38187 void *argp1 = 0 ;
38188 int res1 = 0 ;
38189 wxColour temp2 ;
38190 PyObject * obj0 = 0 ;
38191 PyObject * obj1 = 0 ;
38192 char * kwnames[] = {
38193 (char *) "self",(char *) "colour", NULL
38194 };
38195
38196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38198 if (!SWIG_IsOK(res1)) {
38199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38200 }
38201 arg1 = reinterpret_cast< wxWindow * >(argp1);
38202 {
38203 arg2 = &temp2;
38204 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38205 }
38206 {
38207 PyThreadState* __tstate = wxPyBeginAllowThreads();
38208 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38209 wxPyEndAllowThreads(__tstate);
38210 if (PyErr_Occurred()) SWIG_fail;
38211 }
38212 {
38213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38214 }
38215 return resultobj;
38216 fail:
38217 return NULL;
38218 }
38219
38220
38221 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38222 PyObject *resultobj = 0;
38223 wxWindow *arg1 = (wxWindow *) 0 ;
38224 wxColour *arg2 = 0 ;
38225 void *argp1 = 0 ;
38226 int res1 = 0 ;
38227 wxColour temp2 ;
38228 PyObject * obj0 = 0 ;
38229 PyObject * obj1 = 0 ;
38230 char * kwnames[] = {
38231 (char *) "self",(char *) "colour", NULL
38232 };
38233
38234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38236 if (!SWIG_IsOK(res1)) {
38237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38238 }
38239 arg1 = reinterpret_cast< wxWindow * >(argp1);
38240 {
38241 arg2 = &temp2;
38242 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38243 }
38244 {
38245 PyThreadState* __tstate = wxPyBeginAllowThreads();
38246 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38247 wxPyEndAllowThreads(__tstate);
38248 if (PyErr_Occurred()) SWIG_fail;
38249 }
38250 resultobj = SWIG_Py_Void();
38251 return resultobj;
38252 fail:
38253 return NULL;
38254 }
38255
38256
38257 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38258 PyObject *resultobj = 0;
38259 wxWindow *arg1 = (wxWindow *) 0 ;
38260 wxColour result;
38261 void *argp1 = 0 ;
38262 int res1 = 0 ;
38263 PyObject *swig_obj[1] ;
38264
38265 if (!args) SWIG_fail;
38266 swig_obj[0] = args;
38267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38268 if (!SWIG_IsOK(res1)) {
38269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38270 }
38271 arg1 = reinterpret_cast< wxWindow * >(argp1);
38272 {
38273 PyThreadState* __tstate = wxPyBeginAllowThreads();
38274 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38275 wxPyEndAllowThreads(__tstate);
38276 if (PyErr_Occurred()) SWIG_fail;
38277 }
38278 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38279 return resultobj;
38280 fail:
38281 return NULL;
38282 }
38283
38284
38285 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38286 PyObject *resultobj = 0;
38287 wxWindow *arg1 = (wxWindow *) 0 ;
38288 wxColour result;
38289 void *argp1 = 0 ;
38290 int res1 = 0 ;
38291 PyObject *swig_obj[1] ;
38292
38293 if (!args) SWIG_fail;
38294 swig_obj[0] = args;
38295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38296 if (!SWIG_IsOK(res1)) {
38297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38298 }
38299 arg1 = reinterpret_cast< wxWindow * >(argp1);
38300 {
38301 PyThreadState* __tstate = wxPyBeginAllowThreads();
38302 result = ((wxWindow const *)arg1)->GetForegroundColour();
38303 wxPyEndAllowThreads(__tstate);
38304 if (PyErr_Occurred()) SWIG_fail;
38305 }
38306 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38307 return resultobj;
38308 fail:
38309 return NULL;
38310 }
38311
38312
38313 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38314 PyObject *resultobj = 0;
38315 wxWindow *arg1 = (wxWindow *) 0 ;
38316 bool result;
38317 void *argp1 = 0 ;
38318 int res1 = 0 ;
38319 PyObject *swig_obj[1] ;
38320
38321 if (!args) SWIG_fail;
38322 swig_obj[0] = args;
38323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38324 if (!SWIG_IsOK(res1)) {
38325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38326 }
38327 arg1 = reinterpret_cast< wxWindow * >(argp1);
38328 {
38329 PyThreadState* __tstate = wxPyBeginAllowThreads();
38330 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38331 wxPyEndAllowThreads(__tstate);
38332 if (PyErr_Occurred()) SWIG_fail;
38333 }
38334 {
38335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38336 }
38337 return resultobj;
38338 fail:
38339 return NULL;
38340 }
38341
38342
38343 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38344 PyObject *resultobj = 0;
38345 wxWindow *arg1 = (wxWindow *) 0 ;
38346 bool result;
38347 void *argp1 = 0 ;
38348 int res1 = 0 ;
38349 PyObject *swig_obj[1] ;
38350
38351 if (!args) SWIG_fail;
38352 swig_obj[0] = args;
38353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38354 if (!SWIG_IsOK(res1)) {
38355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38356 }
38357 arg1 = reinterpret_cast< wxWindow * >(argp1);
38358 {
38359 PyThreadState* __tstate = wxPyBeginAllowThreads();
38360 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38361 wxPyEndAllowThreads(__tstate);
38362 if (PyErr_Occurred()) SWIG_fail;
38363 }
38364 {
38365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38366 }
38367 return resultobj;
38368 fail:
38369 return NULL;
38370 }
38371
38372
38373 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38374 PyObject *resultobj = 0;
38375 wxWindow *arg1 = (wxWindow *) 0 ;
38376 wxBackgroundStyle arg2 ;
38377 bool result;
38378 void *argp1 = 0 ;
38379 int res1 = 0 ;
38380 int val2 ;
38381 int ecode2 = 0 ;
38382 PyObject * obj0 = 0 ;
38383 PyObject * obj1 = 0 ;
38384 char * kwnames[] = {
38385 (char *) "self",(char *) "style", NULL
38386 };
38387
38388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38390 if (!SWIG_IsOK(res1)) {
38391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38392 }
38393 arg1 = reinterpret_cast< wxWindow * >(argp1);
38394 ecode2 = SWIG_AsVal_int(obj1, &val2);
38395 if (!SWIG_IsOK(ecode2)) {
38396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38397 }
38398 arg2 = static_cast< wxBackgroundStyle >(val2);
38399 {
38400 PyThreadState* __tstate = wxPyBeginAllowThreads();
38401 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38402 wxPyEndAllowThreads(__tstate);
38403 if (PyErr_Occurred()) SWIG_fail;
38404 }
38405 {
38406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38407 }
38408 return resultobj;
38409 fail:
38410 return NULL;
38411 }
38412
38413
38414 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38415 PyObject *resultobj = 0;
38416 wxWindow *arg1 = (wxWindow *) 0 ;
38417 wxBackgroundStyle result;
38418 void *argp1 = 0 ;
38419 int res1 = 0 ;
38420 PyObject *swig_obj[1] ;
38421
38422 if (!args) SWIG_fail;
38423 swig_obj[0] = args;
38424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38425 if (!SWIG_IsOK(res1)) {
38426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38427 }
38428 arg1 = reinterpret_cast< wxWindow * >(argp1);
38429 {
38430 PyThreadState* __tstate = wxPyBeginAllowThreads();
38431 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38432 wxPyEndAllowThreads(__tstate);
38433 if (PyErr_Occurred()) SWIG_fail;
38434 }
38435 resultobj = SWIG_From_int(static_cast< int >(result));
38436 return resultobj;
38437 fail:
38438 return NULL;
38439 }
38440
38441
38442 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38443 PyObject *resultobj = 0;
38444 wxWindow *arg1 = (wxWindow *) 0 ;
38445 bool result;
38446 void *argp1 = 0 ;
38447 int res1 = 0 ;
38448 PyObject *swig_obj[1] ;
38449
38450 if (!args) SWIG_fail;
38451 swig_obj[0] = args;
38452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38453 if (!SWIG_IsOK(res1)) {
38454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38455 }
38456 arg1 = reinterpret_cast< wxWindow * >(argp1);
38457 {
38458 PyThreadState* __tstate = wxPyBeginAllowThreads();
38459 result = (bool)(arg1)->HasTransparentBackground();
38460 wxPyEndAllowThreads(__tstate);
38461 if (PyErr_Occurred()) SWIG_fail;
38462 }
38463 {
38464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38465 }
38466 return resultobj;
38467 fail:
38468 return NULL;
38469 }
38470
38471
38472 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38473 PyObject *resultobj = 0;
38474 wxWindow *arg1 = (wxWindow *) 0 ;
38475 wxCursor *arg2 = 0 ;
38476 bool result;
38477 void *argp1 = 0 ;
38478 int res1 = 0 ;
38479 void *argp2 = 0 ;
38480 int res2 = 0 ;
38481 PyObject * obj0 = 0 ;
38482 PyObject * obj1 = 0 ;
38483 char * kwnames[] = {
38484 (char *) "self",(char *) "cursor", NULL
38485 };
38486
38487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38489 if (!SWIG_IsOK(res1)) {
38490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38491 }
38492 arg1 = reinterpret_cast< wxWindow * >(argp1);
38493 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38494 if (!SWIG_IsOK(res2)) {
38495 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38496 }
38497 if (!argp2) {
38498 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38499 }
38500 arg2 = reinterpret_cast< wxCursor * >(argp2);
38501 {
38502 PyThreadState* __tstate = wxPyBeginAllowThreads();
38503 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38504 wxPyEndAllowThreads(__tstate);
38505 if (PyErr_Occurred()) SWIG_fail;
38506 }
38507 {
38508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38509 }
38510 return resultobj;
38511 fail:
38512 return NULL;
38513 }
38514
38515
38516 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38517 PyObject *resultobj = 0;
38518 wxWindow *arg1 = (wxWindow *) 0 ;
38519 wxCursor result;
38520 void *argp1 = 0 ;
38521 int res1 = 0 ;
38522 PyObject *swig_obj[1] ;
38523
38524 if (!args) SWIG_fail;
38525 swig_obj[0] = args;
38526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38527 if (!SWIG_IsOK(res1)) {
38528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38529 }
38530 arg1 = reinterpret_cast< wxWindow * >(argp1);
38531 {
38532 PyThreadState* __tstate = wxPyBeginAllowThreads();
38533 result = (arg1)->GetCursor();
38534 wxPyEndAllowThreads(__tstate);
38535 if (PyErr_Occurred()) SWIG_fail;
38536 }
38537 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38538 return resultobj;
38539 fail:
38540 return NULL;
38541 }
38542
38543
38544 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38545 PyObject *resultobj = 0;
38546 wxWindow *arg1 = (wxWindow *) 0 ;
38547 wxFont *arg2 = 0 ;
38548 bool result;
38549 void *argp1 = 0 ;
38550 int res1 = 0 ;
38551 void *argp2 = 0 ;
38552 int res2 = 0 ;
38553 PyObject * obj0 = 0 ;
38554 PyObject * obj1 = 0 ;
38555 char * kwnames[] = {
38556 (char *) "self",(char *) "font", NULL
38557 };
38558
38559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38561 if (!SWIG_IsOK(res1)) {
38562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38563 }
38564 arg1 = reinterpret_cast< wxWindow * >(argp1);
38565 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38566 if (!SWIG_IsOK(res2)) {
38567 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38568 }
38569 if (!argp2) {
38570 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38571 }
38572 arg2 = reinterpret_cast< wxFont * >(argp2);
38573 {
38574 PyThreadState* __tstate = wxPyBeginAllowThreads();
38575 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38576 wxPyEndAllowThreads(__tstate);
38577 if (PyErr_Occurred()) SWIG_fail;
38578 }
38579 {
38580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38581 }
38582 return resultobj;
38583 fail:
38584 return NULL;
38585 }
38586
38587
38588 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38589 PyObject *resultobj = 0;
38590 wxWindow *arg1 = (wxWindow *) 0 ;
38591 wxFont *arg2 = 0 ;
38592 void *argp1 = 0 ;
38593 int res1 = 0 ;
38594 void *argp2 = 0 ;
38595 int res2 = 0 ;
38596 PyObject * obj0 = 0 ;
38597 PyObject * obj1 = 0 ;
38598 char * kwnames[] = {
38599 (char *) "self",(char *) "font", NULL
38600 };
38601
38602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38604 if (!SWIG_IsOK(res1)) {
38605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38606 }
38607 arg1 = reinterpret_cast< wxWindow * >(argp1);
38608 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38609 if (!SWIG_IsOK(res2)) {
38610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38611 }
38612 if (!argp2) {
38613 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38614 }
38615 arg2 = reinterpret_cast< wxFont * >(argp2);
38616 {
38617 PyThreadState* __tstate = wxPyBeginAllowThreads();
38618 (arg1)->SetOwnFont((wxFont const &)*arg2);
38619 wxPyEndAllowThreads(__tstate);
38620 if (PyErr_Occurred()) SWIG_fail;
38621 }
38622 resultobj = SWIG_Py_Void();
38623 return resultobj;
38624 fail:
38625 return NULL;
38626 }
38627
38628
38629 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38630 PyObject *resultobj = 0;
38631 wxWindow *arg1 = (wxWindow *) 0 ;
38632 wxFont result;
38633 void *argp1 = 0 ;
38634 int res1 = 0 ;
38635 PyObject *swig_obj[1] ;
38636
38637 if (!args) SWIG_fail;
38638 swig_obj[0] = args;
38639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38640 if (!SWIG_IsOK(res1)) {
38641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38642 }
38643 arg1 = reinterpret_cast< wxWindow * >(argp1);
38644 {
38645 PyThreadState* __tstate = wxPyBeginAllowThreads();
38646 result = (arg1)->GetFont();
38647 wxPyEndAllowThreads(__tstate);
38648 if (PyErr_Occurred()) SWIG_fail;
38649 }
38650 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
38651 return resultobj;
38652 fail:
38653 return NULL;
38654 }
38655
38656
38657 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38658 PyObject *resultobj = 0;
38659 wxWindow *arg1 = (wxWindow *) 0 ;
38660 wxCaret *arg2 = (wxCaret *) 0 ;
38661 void *argp1 = 0 ;
38662 int res1 = 0 ;
38663 int res2 = 0 ;
38664 PyObject * obj0 = 0 ;
38665 PyObject * obj1 = 0 ;
38666 char * kwnames[] = {
38667 (char *) "self",(char *) "caret", NULL
38668 };
38669
38670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
38671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38672 if (!SWIG_IsOK(res1)) {
38673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
38674 }
38675 arg1 = reinterpret_cast< wxWindow * >(argp1);
38676 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
38677 if (!SWIG_IsOK(res2)) {
38678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
38679 }
38680 {
38681 PyThreadState* __tstate = wxPyBeginAllowThreads();
38682 (arg1)->SetCaret(arg2);
38683 wxPyEndAllowThreads(__tstate);
38684 if (PyErr_Occurred()) SWIG_fail;
38685 }
38686 resultobj = SWIG_Py_Void();
38687 return resultobj;
38688 fail:
38689 return NULL;
38690 }
38691
38692
38693 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38694 PyObject *resultobj = 0;
38695 wxWindow *arg1 = (wxWindow *) 0 ;
38696 wxCaret *result = 0 ;
38697 void *argp1 = 0 ;
38698 int res1 = 0 ;
38699 PyObject *swig_obj[1] ;
38700
38701 if (!args) SWIG_fail;
38702 swig_obj[0] = args;
38703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38704 if (!SWIG_IsOK(res1)) {
38705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
38706 }
38707 arg1 = reinterpret_cast< wxWindow * >(argp1);
38708 {
38709 PyThreadState* __tstate = wxPyBeginAllowThreads();
38710 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
38711 wxPyEndAllowThreads(__tstate);
38712 if (PyErr_Occurred()) SWIG_fail;
38713 }
38714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
38715 return resultobj;
38716 fail:
38717 return NULL;
38718 }
38719
38720
38721 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38722 PyObject *resultobj = 0;
38723 wxWindow *arg1 = (wxWindow *) 0 ;
38724 int result;
38725 void *argp1 = 0 ;
38726 int res1 = 0 ;
38727 PyObject *swig_obj[1] ;
38728
38729 if (!args) SWIG_fail;
38730 swig_obj[0] = args;
38731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38732 if (!SWIG_IsOK(res1)) {
38733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
38734 }
38735 arg1 = reinterpret_cast< wxWindow * >(argp1);
38736 {
38737 PyThreadState* __tstate = wxPyBeginAllowThreads();
38738 result = (int)((wxWindow const *)arg1)->GetCharHeight();
38739 wxPyEndAllowThreads(__tstate);
38740 if (PyErr_Occurred()) SWIG_fail;
38741 }
38742 resultobj = SWIG_From_int(static_cast< int >(result));
38743 return resultobj;
38744 fail:
38745 return NULL;
38746 }
38747
38748
38749 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38750 PyObject *resultobj = 0;
38751 wxWindow *arg1 = (wxWindow *) 0 ;
38752 int result;
38753 void *argp1 = 0 ;
38754 int res1 = 0 ;
38755 PyObject *swig_obj[1] ;
38756
38757 if (!args) SWIG_fail;
38758 swig_obj[0] = args;
38759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38760 if (!SWIG_IsOK(res1)) {
38761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
38762 }
38763 arg1 = reinterpret_cast< wxWindow * >(argp1);
38764 {
38765 PyThreadState* __tstate = wxPyBeginAllowThreads();
38766 result = (int)((wxWindow const *)arg1)->GetCharWidth();
38767 wxPyEndAllowThreads(__tstate);
38768 if (PyErr_Occurred()) SWIG_fail;
38769 }
38770 resultobj = SWIG_From_int(static_cast< int >(result));
38771 return resultobj;
38772 fail:
38773 return NULL;
38774 }
38775
38776
38777 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38778 PyObject *resultobj = 0;
38779 wxWindow *arg1 = (wxWindow *) 0 ;
38780 wxString *arg2 = 0 ;
38781 int *arg3 = (int *) 0 ;
38782 int *arg4 = (int *) 0 ;
38783 void *argp1 = 0 ;
38784 int res1 = 0 ;
38785 bool temp2 = false ;
38786 int temp3 ;
38787 int res3 = SWIG_TMPOBJ ;
38788 int temp4 ;
38789 int res4 = SWIG_TMPOBJ ;
38790 PyObject * obj0 = 0 ;
38791 PyObject * obj1 = 0 ;
38792 char * kwnames[] = {
38793 (char *) "self",(char *) "string", NULL
38794 };
38795
38796 arg3 = &temp3;
38797 arg4 = &temp4;
38798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
38799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38800 if (!SWIG_IsOK(res1)) {
38801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38802 }
38803 arg1 = reinterpret_cast< wxWindow * >(argp1);
38804 {
38805 arg2 = wxString_in_helper(obj1);
38806 if (arg2 == NULL) SWIG_fail;
38807 temp2 = true;
38808 }
38809 {
38810 PyThreadState* __tstate = wxPyBeginAllowThreads();
38811 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
38812 wxPyEndAllowThreads(__tstate);
38813 if (PyErr_Occurred()) SWIG_fail;
38814 }
38815 resultobj = SWIG_Py_Void();
38816 if (SWIG_IsTmpObj(res3)) {
38817 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38818 } else {
38819 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38820 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38821 }
38822 if (SWIG_IsTmpObj(res4)) {
38823 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38824 } else {
38825 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38826 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38827 }
38828 {
38829 if (temp2)
38830 delete arg2;
38831 }
38832 return resultobj;
38833 fail:
38834 {
38835 if (temp2)
38836 delete arg2;
38837 }
38838 return NULL;
38839 }
38840
38841
38842 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38843 PyObject *resultobj = 0;
38844 wxWindow *arg1 = (wxWindow *) 0 ;
38845 wxString *arg2 = 0 ;
38846 int *arg3 = (int *) 0 ;
38847 int *arg4 = (int *) 0 ;
38848 int *arg5 = (int *) 0 ;
38849 int *arg6 = (int *) 0 ;
38850 wxFont *arg7 = (wxFont *) NULL ;
38851 void *argp1 = 0 ;
38852 int res1 = 0 ;
38853 bool temp2 = false ;
38854 int temp3 ;
38855 int res3 = SWIG_TMPOBJ ;
38856 int temp4 ;
38857 int res4 = SWIG_TMPOBJ ;
38858 int temp5 ;
38859 int res5 = SWIG_TMPOBJ ;
38860 int temp6 ;
38861 int res6 = SWIG_TMPOBJ ;
38862 void *argp7 = 0 ;
38863 int res7 = 0 ;
38864 PyObject * obj0 = 0 ;
38865 PyObject * obj1 = 0 ;
38866 PyObject * obj2 = 0 ;
38867 char * kwnames[] = {
38868 (char *) "self",(char *) "string",(char *) "font", NULL
38869 };
38870
38871 arg3 = &temp3;
38872 arg4 = &temp4;
38873 arg5 = &temp5;
38874 arg6 = &temp6;
38875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38877 if (!SWIG_IsOK(res1)) {
38878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38879 }
38880 arg1 = reinterpret_cast< wxWindow * >(argp1);
38881 {
38882 arg2 = wxString_in_helper(obj1);
38883 if (arg2 == NULL) SWIG_fail;
38884 temp2 = true;
38885 }
38886 if (obj2) {
38887 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
38888 if (!SWIG_IsOK(res7)) {
38889 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
38890 }
38891 arg7 = reinterpret_cast< wxFont * >(argp7);
38892 }
38893 {
38894 PyThreadState* __tstate = wxPyBeginAllowThreads();
38895 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
38896 wxPyEndAllowThreads(__tstate);
38897 if (PyErr_Occurred()) SWIG_fail;
38898 }
38899 resultobj = SWIG_Py_Void();
38900 if (SWIG_IsTmpObj(res3)) {
38901 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38902 } else {
38903 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38904 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38905 }
38906 if (SWIG_IsTmpObj(res4)) {
38907 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38908 } else {
38909 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38910 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38911 }
38912 if (SWIG_IsTmpObj(res5)) {
38913 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
38914 } else {
38915 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38916 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
38917 }
38918 if (SWIG_IsTmpObj(res6)) {
38919 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
38920 } else {
38921 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38922 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
38923 }
38924 {
38925 if (temp2)
38926 delete arg2;
38927 }
38928 return resultobj;
38929 fail:
38930 {
38931 if (temp2)
38932 delete arg2;
38933 }
38934 return NULL;
38935 }
38936
38937
38938 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38939 PyObject *resultobj = 0;
38940 wxWindow *arg1 = (wxWindow *) 0 ;
38941 int *arg2 = (int *) 0 ;
38942 int *arg3 = (int *) 0 ;
38943 void *argp1 = 0 ;
38944 int res1 = 0 ;
38945 int temp2 ;
38946 int res2 = 0 ;
38947 int temp3 ;
38948 int res3 = 0 ;
38949 PyObject * obj0 = 0 ;
38950 PyObject * obj1 = 0 ;
38951 PyObject * obj2 = 0 ;
38952 char * kwnames[] = {
38953 (char *) "self",(char *) "x",(char *) "y", NULL
38954 };
38955
38956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38958 if (!SWIG_IsOK(res1)) {
38959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
38960 }
38961 arg1 = reinterpret_cast< wxWindow * >(argp1);
38962 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
38963 int val;
38964 int ecode = SWIG_AsVal_int(obj1, &val);
38965 if (!SWIG_IsOK(ecode)) {
38966 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
38967 }
38968 temp2 = static_cast< int >(val);
38969 arg2 = &temp2;
38970 res2 = SWIG_AddTmpMask(ecode);
38971 }
38972 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
38973 int val;
38974 int ecode = SWIG_AsVal_int(obj2, &val);
38975 if (!SWIG_IsOK(ecode)) {
38976 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
38977 }
38978 temp3 = static_cast< int >(val);
38979 arg3 = &temp3;
38980 res3 = SWIG_AddTmpMask(ecode);
38981 }
38982 {
38983 PyThreadState* __tstate = wxPyBeginAllowThreads();
38984 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
38985 wxPyEndAllowThreads(__tstate);
38986 if (PyErr_Occurred()) SWIG_fail;
38987 }
38988 resultobj = SWIG_Py_Void();
38989 if (SWIG_IsTmpObj(res2)) {
38990 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
38991 } else {
38992 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38993 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
38994 }
38995 if (SWIG_IsTmpObj(res3)) {
38996 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38997 } else {
38998 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38999 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39000 }
39001 return resultobj;
39002 fail:
39003 return NULL;
39004 }
39005
39006
39007 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39008 PyObject *resultobj = 0;
39009 wxWindow *arg1 = (wxWindow *) 0 ;
39010 int *arg2 = (int *) 0 ;
39011 int *arg3 = (int *) 0 ;
39012 void *argp1 = 0 ;
39013 int res1 = 0 ;
39014 int temp2 ;
39015 int res2 = 0 ;
39016 int temp3 ;
39017 int res3 = 0 ;
39018 PyObject * obj0 = 0 ;
39019 PyObject * obj1 = 0 ;
39020 PyObject * obj2 = 0 ;
39021 char * kwnames[] = {
39022 (char *) "self",(char *) "x",(char *) "y", NULL
39023 };
39024
39025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39027 if (!SWIG_IsOK(res1)) {
39028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39029 }
39030 arg1 = reinterpret_cast< wxWindow * >(argp1);
39031 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39032 int val;
39033 int ecode = SWIG_AsVal_int(obj1, &val);
39034 if (!SWIG_IsOK(ecode)) {
39035 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39036 }
39037 temp2 = static_cast< int >(val);
39038 arg2 = &temp2;
39039 res2 = SWIG_AddTmpMask(ecode);
39040 }
39041 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39042 int val;
39043 int ecode = SWIG_AsVal_int(obj2, &val);
39044 if (!SWIG_IsOK(ecode)) {
39045 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39046 }
39047 temp3 = static_cast< int >(val);
39048 arg3 = &temp3;
39049 res3 = SWIG_AddTmpMask(ecode);
39050 }
39051 {
39052 PyThreadState* __tstate = wxPyBeginAllowThreads();
39053 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39054 wxPyEndAllowThreads(__tstate);
39055 if (PyErr_Occurred()) SWIG_fail;
39056 }
39057 resultobj = SWIG_Py_Void();
39058 if (SWIG_IsTmpObj(res2)) {
39059 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39060 } else {
39061 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39062 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39063 }
39064 if (SWIG_IsTmpObj(res3)) {
39065 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39066 } else {
39067 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39068 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39069 }
39070 return resultobj;
39071 fail:
39072 return NULL;
39073 }
39074
39075
39076 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39077 PyObject *resultobj = 0;
39078 wxWindow *arg1 = (wxWindow *) 0 ;
39079 wxPoint *arg2 = 0 ;
39080 wxPoint result;
39081 void *argp1 = 0 ;
39082 int res1 = 0 ;
39083 wxPoint temp2 ;
39084 PyObject * obj0 = 0 ;
39085 PyObject * obj1 = 0 ;
39086 char * kwnames[] = {
39087 (char *) "self",(char *) "pt", NULL
39088 };
39089
39090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39092 if (!SWIG_IsOK(res1)) {
39093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39094 }
39095 arg1 = reinterpret_cast< wxWindow * >(argp1);
39096 {
39097 arg2 = &temp2;
39098 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39099 }
39100 {
39101 PyThreadState* __tstate = wxPyBeginAllowThreads();
39102 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39103 wxPyEndAllowThreads(__tstate);
39104 if (PyErr_Occurred()) SWIG_fail;
39105 }
39106 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39107 return resultobj;
39108 fail:
39109 return NULL;
39110 }
39111
39112
39113 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39114 PyObject *resultobj = 0;
39115 wxWindow *arg1 = (wxWindow *) 0 ;
39116 wxPoint *arg2 = 0 ;
39117 wxPoint result;
39118 void *argp1 = 0 ;
39119 int res1 = 0 ;
39120 wxPoint temp2 ;
39121 PyObject * obj0 = 0 ;
39122 PyObject * obj1 = 0 ;
39123 char * kwnames[] = {
39124 (char *) "self",(char *) "pt", NULL
39125 };
39126
39127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39129 if (!SWIG_IsOK(res1)) {
39130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39131 }
39132 arg1 = reinterpret_cast< wxWindow * >(argp1);
39133 {
39134 arg2 = &temp2;
39135 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39136 }
39137 {
39138 PyThreadState* __tstate = wxPyBeginAllowThreads();
39139 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39140 wxPyEndAllowThreads(__tstate);
39141 if (PyErr_Occurred()) SWIG_fail;
39142 }
39143 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39144 return resultobj;
39145 fail:
39146 return NULL;
39147 }
39148
39149
39150 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39151 PyObject *resultobj = 0;
39152 wxWindow *arg1 = (wxWindow *) 0 ;
39153 int arg2 ;
39154 int arg3 ;
39155 wxHitTest result;
39156 void *argp1 = 0 ;
39157 int res1 = 0 ;
39158 int val2 ;
39159 int ecode2 = 0 ;
39160 int val3 ;
39161 int ecode3 = 0 ;
39162 PyObject * obj0 = 0 ;
39163 PyObject * obj1 = 0 ;
39164 PyObject * obj2 = 0 ;
39165 char * kwnames[] = {
39166 (char *) "self",(char *) "x",(char *) "y", NULL
39167 };
39168
39169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39171 if (!SWIG_IsOK(res1)) {
39172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39173 }
39174 arg1 = reinterpret_cast< wxWindow * >(argp1);
39175 ecode2 = SWIG_AsVal_int(obj1, &val2);
39176 if (!SWIG_IsOK(ecode2)) {
39177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39178 }
39179 arg2 = static_cast< int >(val2);
39180 ecode3 = SWIG_AsVal_int(obj2, &val3);
39181 if (!SWIG_IsOK(ecode3)) {
39182 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39183 }
39184 arg3 = static_cast< int >(val3);
39185 {
39186 PyThreadState* __tstate = wxPyBeginAllowThreads();
39187 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39188 wxPyEndAllowThreads(__tstate);
39189 if (PyErr_Occurred()) SWIG_fail;
39190 }
39191 resultobj = SWIG_From_int(static_cast< int >(result));
39192 return resultobj;
39193 fail:
39194 return NULL;
39195 }
39196
39197
39198 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39199 PyObject *resultobj = 0;
39200 wxWindow *arg1 = (wxWindow *) 0 ;
39201 wxPoint *arg2 = 0 ;
39202 wxHitTest result;
39203 void *argp1 = 0 ;
39204 int res1 = 0 ;
39205 wxPoint temp2 ;
39206 PyObject * obj0 = 0 ;
39207 PyObject * obj1 = 0 ;
39208 char * kwnames[] = {
39209 (char *) "self",(char *) "pt", NULL
39210 };
39211
39212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39214 if (!SWIG_IsOK(res1)) {
39215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39216 }
39217 arg1 = reinterpret_cast< wxWindow * >(argp1);
39218 {
39219 arg2 = &temp2;
39220 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39221 }
39222 {
39223 PyThreadState* __tstate = wxPyBeginAllowThreads();
39224 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39225 wxPyEndAllowThreads(__tstate);
39226 if (PyErr_Occurred()) SWIG_fail;
39227 }
39228 resultobj = SWIG_From_int(static_cast< int >(result));
39229 return resultobj;
39230 fail:
39231 return NULL;
39232 }
39233
39234
39235 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39236 PyObject *resultobj = 0;
39237 wxWindow *arg1 = (wxWindow *) 0 ;
39238 long arg2 ;
39239 wxBorder result;
39240 void *argp1 = 0 ;
39241 int res1 = 0 ;
39242 long val2 ;
39243 int ecode2 = 0 ;
39244
39245 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39247 if (!SWIG_IsOK(res1)) {
39248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39249 }
39250 arg1 = reinterpret_cast< wxWindow * >(argp1);
39251 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39252 if (!SWIG_IsOK(ecode2)) {
39253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39254 }
39255 arg2 = static_cast< long >(val2);
39256 {
39257 PyThreadState* __tstate = wxPyBeginAllowThreads();
39258 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39259 wxPyEndAllowThreads(__tstate);
39260 if (PyErr_Occurred()) SWIG_fail;
39261 }
39262 resultobj = SWIG_From_int(static_cast< int >(result));
39263 return resultobj;
39264 fail:
39265 return NULL;
39266 }
39267
39268
39269 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39270 PyObject *resultobj = 0;
39271 wxWindow *arg1 = (wxWindow *) 0 ;
39272 wxBorder result;
39273 void *argp1 = 0 ;
39274 int res1 = 0 ;
39275
39276 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39278 if (!SWIG_IsOK(res1)) {
39279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39280 }
39281 arg1 = reinterpret_cast< wxWindow * >(argp1);
39282 {
39283 PyThreadState* __tstate = wxPyBeginAllowThreads();
39284 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39285 wxPyEndAllowThreads(__tstate);
39286 if (PyErr_Occurred()) SWIG_fail;
39287 }
39288 resultobj = SWIG_From_int(static_cast< int >(result));
39289 return resultobj;
39290 fail:
39291 return NULL;
39292 }
39293
39294
39295 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39296 int argc;
39297 PyObject *argv[3];
39298
39299 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39300 --argc;
39301 if (argc == 1) {
39302 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39303 }
39304 if (argc == 2) {
39305 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39306 }
39307
39308 fail:
39309 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39310 return NULL;
39311 }
39312
39313
39314 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39315 PyObject *resultobj = 0;
39316 wxWindow *arg1 = (wxWindow *) 0 ;
39317 long arg2 = (long) wxUPDATE_UI_NONE ;
39318 void *argp1 = 0 ;
39319 int res1 = 0 ;
39320 long val2 ;
39321 int ecode2 = 0 ;
39322 PyObject * obj0 = 0 ;
39323 PyObject * obj1 = 0 ;
39324 char * kwnames[] = {
39325 (char *) "self",(char *) "flags", NULL
39326 };
39327
39328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39330 if (!SWIG_IsOK(res1)) {
39331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39332 }
39333 arg1 = reinterpret_cast< wxWindow * >(argp1);
39334 if (obj1) {
39335 ecode2 = SWIG_AsVal_long(obj1, &val2);
39336 if (!SWIG_IsOK(ecode2)) {
39337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39338 }
39339 arg2 = static_cast< long >(val2);
39340 }
39341 {
39342 PyThreadState* __tstate = wxPyBeginAllowThreads();
39343 (arg1)->UpdateWindowUI(arg2);
39344 wxPyEndAllowThreads(__tstate);
39345 if (PyErr_Occurred()) SWIG_fail;
39346 }
39347 resultobj = SWIG_Py_Void();
39348 return resultobj;
39349 fail:
39350 return NULL;
39351 }
39352
39353
39354 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39355 PyObject *resultobj = 0;
39356 wxWindow *arg1 = (wxWindow *) 0 ;
39357 wxMenu *arg2 = (wxMenu *) 0 ;
39358 int arg3 = (int) -1 ;
39359 int arg4 = (int) -1 ;
39360 bool result;
39361 void *argp1 = 0 ;
39362 int res1 = 0 ;
39363 void *argp2 = 0 ;
39364 int res2 = 0 ;
39365 int val3 ;
39366 int ecode3 = 0 ;
39367 int val4 ;
39368 int ecode4 = 0 ;
39369 PyObject * obj0 = 0 ;
39370 PyObject * obj1 = 0 ;
39371 PyObject * obj2 = 0 ;
39372 PyObject * obj3 = 0 ;
39373 char * kwnames[] = {
39374 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39375 };
39376
39377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39379 if (!SWIG_IsOK(res1)) {
39380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39381 }
39382 arg1 = reinterpret_cast< wxWindow * >(argp1);
39383 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39384 if (!SWIG_IsOK(res2)) {
39385 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39386 }
39387 arg2 = reinterpret_cast< wxMenu * >(argp2);
39388 if (obj2) {
39389 ecode3 = SWIG_AsVal_int(obj2, &val3);
39390 if (!SWIG_IsOK(ecode3)) {
39391 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39392 }
39393 arg3 = static_cast< int >(val3);
39394 }
39395 if (obj3) {
39396 ecode4 = SWIG_AsVal_int(obj3, &val4);
39397 if (!SWIG_IsOK(ecode4)) {
39398 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39399 }
39400 arg4 = static_cast< int >(val4);
39401 }
39402 {
39403 PyThreadState* __tstate = wxPyBeginAllowThreads();
39404 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39405 wxPyEndAllowThreads(__tstate);
39406 if (PyErr_Occurred()) SWIG_fail;
39407 }
39408 {
39409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39410 }
39411 return resultobj;
39412 fail:
39413 return NULL;
39414 }
39415
39416
39417 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39418 PyObject *resultobj = 0;
39419 wxWindow *arg1 = (wxWindow *) 0 ;
39420 wxMenu *arg2 = (wxMenu *) 0 ;
39421 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39422 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39423 bool result;
39424 void *argp1 = 0 ;
39425 int res1 = 0 ;
39426 void *argp2 = 0 ;
39427 int res2 = 0 ;
39428 wxPoint temp3 ;
39429 PyObject * obj0 = 0 ;
39430 PyObject * obj1 = 0 ;
39431 PyObject * obj2 = 0 ;
39432 char * kwnames[] = {
39433 (char *) "self",(char *) "menu",(char *) "pos", NULL
39434 };
39435
39436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39438 if (!SWIG_IsOK(res1)) {
39439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39440 }
39441 arg1 = reinterpret_cast< wxWindow * >(argp1);
39442 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39443 if (!SWIG_IsOK(res2)) {
39444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39445 }
39446 arg2 = reinterpret_cast< wxMenu * >(argp2);
39447 if (obj2) {
39448 {
39449 arg3 = &temp3;
39450 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39451 }
39452 }
39453 {
39454 PyThreadState* __tstate = wxPyBeginAllowThreads();
39455 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39456 wxPyEndAllowThreads(__tstate);
39457 if (PyErr_Occurred()) SWIG_fail;
39458 }
39459 {
39460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39461 }
39462 return resultobj;
39463 fail:
39464 return NULL;
39465 }
39466
39467
39468 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39469 PyObject *resultobj = 0;
39470 wxWindow *arg1 = (wxWindow *) 0 ;
39471 bool result;
39472 void *argp1 = 0 ;
39473 int res1 = 0 ;
39474 PyObject *swig_obj[1] ;
39475
39476 if (!args) SWIG_fail;
39477 swig_obj[0] = args;
39478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39479 if (!SWIG_IsOK(res1)) {
39480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39481 }
39482 arg1 = reinterpret_cast< wxWindow * >(argp1);
39483 {
39484 PyThreadState* __tstate = wxPyBeginAllowThreads();
39485 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39486 wxPyEndAllowThreads(__tstate);
39487 if (PyErr_Occurred()) SWIG_fail;
39488 }
39489 {
39490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39491 }
39492 return resultobj;
39493 fail:
39494 return NULL;
39495 }
39496
39497
39498 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39499 PyObject *resultobj = 0;
39500 wxWindow *arg1 = (wxWindow *) 0 ;
39501 long result;
39502 void *argp1 = 0 ;
39503 int res1 = 0 ;
39504 PyObject *swig_obj[1] ;
39505
39506 if (!args) SWIG_fail;
39507 swig_obj[0] = args;
39508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39509 if (!SWIG_IsOK(res1)) {
39510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39511 }
39512 arg1 = reinterpret_cast< wxWindow * >(argp1);
39513 {
39514 PyThreadState* __tstate = wxPyBeginAllowThreads();
39515 result = (long)wxWindow_GetHandle(arg1);
39516 wxPyEndAllowThreads(__tstate);
39517 if (PyErr_Occurred()) SWIG_fail;
39518 }
39519 resultobj = SWIG_From_long(static_cast< long >(result));
39520 return resultobj;
39521 fail:
39522 return NULL;
39523 }
39524
39525
39526 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39527 PyObject *resultobj = 0;
39528 wxWindow *arg1 = (wxWindow *) 0 ;
39529 long arg2 ;
39530 void *argp1 = 0 ;
39531 int res1 = 0 ;
39532 long val2 ;
39533 int ecode2 = 0 ;
39534 PyObject * obj0 = 0 ;
39535 PyObject * obj1 = 0 ;
39536 char * kwnames[] = {
39537 (char *) "self",(char *) "handle", NULL
39538 };
39539
39540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39542 if (!SWIG_IsOK(res1)) {
39543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39544 }
39545 arg1 = reinterpret_cast< wxWindow * >(argp1);
39546 ecode2 = SWIG_AsVal_long(obj1, &val2);
39547 if (!SWIG_IsOK(ecode2)) {
39548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39549 }
39550 arg2 = static_cast< long >(val2);
39551 {
39552 PyThreadState* __tstate = wxPyBeginAllowThreads();
39553 wxWindow_AssociateHandle(arg1,arg2);
39554 wxPyEndAllowThreads(__tstate);
39555 if (PyErr_Occurred()) SWIG_fail;
39556 }
39557 resultobj = SWIG_Py_Void();
39558 return resultobj;
39559 fail:
39560 return NULL;
39561 }
39562
39563
39564 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39565 PyObject *resultobj = 0;
39566 wxWindow *arg1 = (wxWindow *) 0 ;
39567 void *argp1 = 0 ;
39568 int res1 = 0 ;
39569 PyObject *swig_obj[1] ;
39570
39571 if (!args) SWIG_fail;
39572 swig_obj[0] = args;
39573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39574 if (!SWIG_IsOK(res1)) {
39575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39576 }
39577 arg1 = reinterpret_cast< wxWindow * >(argp1);
39578 {
39579 PyThreadState* __tstate = wxPyBeginAllowThreads();
39580 (arg1)->DissociateHandle();
39581 wxPyEndAllowThreads(__tstate);
39582 if (PyErr_Occurred()) SWIG_fail;
39583 }
39584 resultobj = SWIG_Py_Void();
39585 return resultobj;
39586 fail:
39587 return NULL;
39588 }
39589
39590
39591 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39592 PyObject *resultobj = 0;
39593 wxWindow *arg1 = (wxWindow *) 0 ;
39594 int arg2 ;
39595 bool result;
39596 void *argp1 = 0 ;
39597 int res1 = 0 ;
39598 int val2 ;
39599 int ecode2 = 0 ;
39600 PyObject * obj0 = 0 ;
39601 PyObject * obj1 = 0 ;
39602 char * kwnames[] = {
39603 (char *) "self",(char *) "orient", NULL
39604 };
39605
39606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
39607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39608 if (!SWIG_IsOK(res1)) {
39609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
39610 }
39611 arg1 = reinterpret_cast< wxWindow * >(argp1);
39612 ecode2 = SWIG_AsVal_int(obj1, &val2);
39613 if (!SWIG_IsOK(ecode2)) {
39614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39615 }
39616 arg2 = static_cast< int >(val2);
39617 {
39618 PyThreadState* __tstate = wxPyBeginAllowThreads();
39619 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39620 wxPyEndAllowThreads(__tstate);
39621 if (PyErr_Occurred()) SWIG_fail;
39622 }
39623 {
39624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39625 }
39626 return resultobj;
39627 fail:
39628 return NULL;
39629 }
39630
39631
39632 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39633 PyObject *resultobj = 0;
39634 wxWindow *arg1 = (wxWindow *) 0 ;
39635 int arg2 ;
39636 int arg3 ;
39637 int arg4 ;
39638 int arg5 ;
39639 bool arg6 = (bool) true ;
39640 void *argp1 = 0 ;
39641 int res1 = 0 ;
39642 int val2 ;
39643 int ecode2 = 0 ;
39644 int val3 ;
39645 int ecode3 = 0 ;
39646 int val4 ;
39647 int ecode4 = 0 ;
39648 int val5 ;
39649 int ecode5 = 0 ;
39650 bool val6 ;
39651 int ecode6 = 0 ;
39652 PyObject * obj0 = 0 ;
39653 PyObject * obj1 = 0 ;
39654 PyObject * obj2 = 0 ;
39655 PyObject * obj3 = 0 ;
39656 PyObject * obj4 = 0 ;
39657 PyObject * obj5 = 0 ;
39658 char * kwnames[] = {
39659 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
39660 };
39661
39662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39664 if (!SWIG_IsOK(res1)) {
39665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
39666 }
39667 arg1 = reinterpret_cast< wxWindow * >(argp1);
39668 ecode2 = SWIG_AsVal_int(obj1, &val2);
39669 if (!SWIG_IsOK(ecode2)) {
39670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
39671 }
39672 arg2 = static_cast< int >(val2);
39673 ecode3 = SWIG_AsVal_int(obj2, &val3);
39674 if (!SWIG_IsOK(ecode3)) {
39675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
39676 }
39677 arg3 = static_cast< int >(val3);
39678 ecode4 = SWIG_AsVal_int(obj3, &val4);
39679 if (!SWIG_IsOK(ecode4)) {
39680 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
39681 }
39682 arg4 = static_cast< int >(val4);
39683 ecode5 = SWIG_AsVal_int(obj4, &val5);
39684 if (!SWIG_IsOK(ecode5)) {
39685 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
39686 }
39687 arg5 = static_cast< int >(val5);
39688 if (obj5) {
39689 ecode6 = SWIG_AsVal_bool(obj5, &val6);
39690 if (!SWIG_IsOK(ecode6)) {
39691 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
39692 }
39693 arg6 = static_cast< bool >(val6);
39694 }
39695 {
39696 PyThreadState* __tstate = wxPyBeginAllowThreads();
39697 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
39698 wxPyEndAllowThreads(__tstate);
39699 if (PyErr_Occurred()) SWIG_fail;
39700 }
39701 resultobj = SWIG_Py_Void();
39702 return resultobj;
39703 fail:
39704 return NULL;
39705 }
39706
39707
39708 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39709 PyObject *resultobj = 0;
39710 wxWindow *arg1 = (wxWindow *) 0 ;
39711 int arg2 ;
39712 int arg3 ;
39713 bool arg4 = (bool) true ;
39714 void *argp1 = 0 ;
39715 int res1 = 0 ;
39716 int val2 ;
39717 int ecode2 = 0 ;
39718 int val3 ;
39719 int ecode3 = 0 ;
39720 bool val4 ;
39721 int ecode4 = 0 ;
39722 PyObject * obj0 = 0 ;
39723 PyObject * obj1 = 0 ;
39724 PyObject * obj2 = 0 ;
39725 PyObject * obj3 = 0 ;
39726 char * kwnames[] = {
39727 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
39728 };
39729
39730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39732 if (!SWIG_IsOK(res1)) {
39733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
39734 }
39735 arg1 = reinterpret_cast< wxWindow * >(argp1);
39736 ecode2 = SWIG_AsVal_int(obj1, &val2);
39737 if (!SWIG_IsOK(ecode2)) {
39738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
39739 }
39740 arg2 = static_cast< int >(val2);
39741 ecode3 = SWIG_AsVal_int(obj2, &val3);
39742 if (!SWIG_IsOK(ecode3)) {
39743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
39744 }
39745 arg3 = static_cast< int >(val3);
39746 if (obj3) {
39747 ecode4 = SWIG_AsVal_bool(obj3, &val4);
39748 if (!SWIG_IsOK(ecode4)) {
39749 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
39750 }
39751 arg4 = static_cast< bool >(val4);
39752 }
39753 {
39754 PyThreadState* __tstate = wxPyBeginAllowThreads();
39755 (arg1)->SetScrollPos(arg2,arg3,arg4);
39756 wxPyEndAllowThreads(__tstate);
39757 if (PyErr_Occurred()) SWIG_fail;
39758 }
39759 resultobj = SWIG_Py_Void();
39760 return resultobj;
39761 fail:
39762 return NULL;
39763 }
39764
39765
39766 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39767 PyObject *resultobj = 0;
39768 wxWindow *arg1 = (wxWindow *) 0 ;
39769 int arg2 ;
39770 int result;
39771 void *argp1 = 0 ;
39772 int res1 = 0 ;
39773 int val2 ;
39774 int ecode2 = 0 ;
39775 PyObject * obj0 = 0 ;
39776 PyObject * obj1 = 0 ;
39777 char * kwnames[] = {
39778 (char *) "self",(char *) "orientation", NULL
39779 };
39780
39781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
39782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39783 if (!SWIG_IsOK(res1)) {
39784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
39785 }
39786 arg1 = reinterpret_cast< wxWindow * >(argp1);
39787 ecode2 = SWIG_AsVal_int(obj1, &val2);
39788 if (!SWIG_IsOK(ecode2)) {
39789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
39790 }
39791 arg2 = static_cast< int >(val2);
39792 {
39793 PyThreadState* __tstate = wxPyBeginAllowThreads();
39794 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
39795 wxPyEndAllowThreads(__tstate);
39796 if (PyErr_Occurred()) SWIG_fail;
39797 }
39798 resultobj = SWIG_From_int(static_cast< int >(result));
39799 return resultobj;
39800 fail:
39801 return NULL;
39802 }
39803
39804
39805 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39806 PyObject *resultobj = 0;
39807 wxWindow *arg1 = (wxWindow *) 0 ;
39808 int arg2 ;
39809 int result;
39810 void *argp1 = 0 ;
39811 int res1 = 0 ;
39812 int val2 ;
39813 int ecode2 = 0 ;
39814 PyObject * obj0 = 0 ;
39815 PyObject * obj1 = 0 ;
39816 char * kwnames[] = {
39817 (char *) "self",(char *) "orientation", NULL
39818 };
39819
39820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
39821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39822 if (!SWIG_IsOK(res1)) {
39823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
39824 }
39825 arg1 = reinterpret_cast< wxWindow * >(argp1);
39826 ecode2 = SWIG_AsVal_int(obj1, &val2);
39827 if (!SWIG_IsOK(ecode2)) {
39828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
39829 }
39830 arg2 = static_cast< int >(val2);
39831 {
39832 PyThreadState* __tstate = wxPyBeginAllowThreads();
39833 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
39834 wxPyEndAllowThreads(__tstate);
39835 if (PyErr_Occurred()) SWIG_fail;
39836 }
39837 resultobj = SWIG_From_int(static_cast< int >(result));
39838 return resultobj;
39839 fail:
39840 return NULL;
39841 }
39842
39843
39844 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39845 PyObject *resultobj = 0;
39846 wxWindow *arg1 = (wxWindow *) 0 ;
39847 int arg2 ;
39848 int result;
39849 void *argp1 = 0 ;
39850 int res1 = 0 ;
39851 int val2 ;
39852 int ecode2 = 0 ;
39853 PyObject * obj0 = 0 ;
39854 PyObject * obj1 = 0 ;
39855 char * kwnames[] = {
39856 (char *) "self",(char *) "orientation", NULL
39857 };
39858
39859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
39860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39861 if (!SWIG_IsOK(res1)) {
39862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
39863 }
39864 arg1 = reinterpret_cast< wxWindow * >(argp1);
39865 ecode2 = SWIG_AsVal_int(obj1, &val2);
39866 if (!SWIG_IsOK(ecode2)) {
39867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
39868 }
39869 arg2 = static_cast< int >(val2);
39870 {
39871 PyThreadState* __tstate = wxPyBeginAllowThreads();
39872 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
39873 wxPyEndAllowThreads(__tstate);
39874 if (PyErr_Occurred()) SWIG_fail;
39875 }
39876 resultobj = SWIG_From_int(static_cast< int >(result));
39877 return resultobj;
39878 fail:
39879 return NULL;
39880 }
39881
39882
39883 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39884 PyObject *resultobj = 0;
39885 wxWindow *arg1 = (wxWindow *) 0 ;
39886 int arg2 ;
39887 int arg3 ;
39888 wxRect *arg4 = (wxRect *) NULL ;
39889 void *argp1 = 0 ;
39890 int res1 = 0 ;
39891 int val2 ;
39892 int ecode2 = 0 ;
39893 int val3 ;
39894 int ecode3 = 0 ;
39895 void *argp4 = 0 ;
39896 int res4 = 0 ;
39897 PyObject * obj0 = 0 ;
39898 PyObject * obj1 = 0 ;
39899 PyObject * obj2 = 0 ;
39900 PyObject * obj3 = 0 ;
39901 char * kwnames[] = {
39902 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
39903 };
39904
39905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39907 if (!SWIG_IsOK(res1)) {
39908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
39909 }
39910 arg1 = reinterpret_cast< wxWindow * >(argp1);
39911 ecode2 = SWIG_AsVal_int(obj1, &val2);
39912 if (!SWIG_IsOK(ecode2)) {
39913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
39914 }
39915 arg2 = static_cast< int >(val2);
39916 ecode3 = SWIG_AsVal_int(obj2, &val3);
39917 if (!SWIG_IsOK(ecode3)) {
39918 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
39919 }
39920 arg3 = static_cast< int >(val3);
39921 if (obj3) {
39922 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
39923 if (!SWIG_IsOK(res4)) {
39924 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
39925 }
39926 arg4 = reinterpret_cast< wxRect * >(argp4);
39927 }
39928 {
39929 PyThreadState* __tstate = wxPyBeginAllowThreads();
39930 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
39931 wxPyEndAllowThreads(__tstate);
39932 if (PyErr_Occurred()) SWIG_fail;
39933 }
39934 resultobj = SWIG_Py_Void();
39935 return resultobj;
39936 fail:
39937 return NULL;
39938 }
39939
39940
39941 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39942 PyObject *resultobj = 0;
39943 wxWindow *arg1 = (wxWindow *) 0 ;
39944 int arg2 ;
39945 bool result;
39946 void *argp1 = 0 ;
39947 int res1 = 0 ;
39948 int val2 ;
39949 int ecode2 = 0 ;
39950 PyObject * obj0 = 0 ;
39951 PyObject * obj1 = 0 ;
39952 char * kwnames[] = {
39953 (char *) "self",(char *) "lines", NULL
39954 };
39955
39956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
39957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39958 if (!SWIG_IsOK(res1)) {
39959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
39960 }
39961 arg1 = reinterpret_cast< wxWindow * >(argp1);
39962 ecode2 = SWIG_AsVal_int(obj1, &val2);
39963 if (!SWIG_IsOK(ecode2)) {
39964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
39965 }
39966 arg2 = static_cast< int >(val2);
39967 {
39968 PyThreadState* __tstate = wxPyBeginAllowThreads();
39969 result = (bool)(arg1)->ScrollLines(arg2);
39970 wxPyEndAllowThreads(__tstate);
39971 if (PyErr_Occurred()) SWIG_fail;
39972 }
39973 {
39974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39975 }
39976 return resultobj;
39977 fail:
39978 return NULL;
39979 }
39980
39981
39982 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39983 PyObject *resultobj = 0;
39984 wxWindow *arg1 = (wxWindow *) 0 ;
39985 int arg2 ;
39986 bool result;
39987 void *argp1 = 0 ;
39988 int res1 = 0 ;
39989 int val2 ;
39990 int ecode2 = 0 ;
39991 PyObject * obj0 = 0 ;
39992 PyObject * obj1 = 0 ;
39993 char * kwnames[] = {
39994 (char *) "self",(char *) "pages", NULL
39995 };
39996
39997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
39998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39999 if (!SWIG_IsOK(res1)) {
40000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40001 }
40002 arg1 = reinterpret_cast< wxWindow * >(argp1);
40003 ecode2 = SWIG_AsVal_int(obj1, &val2);
40004 if (!SWIG_IsOK(ecode2)) {
40005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40006 }
40007 arg2 = static_cast< int >(val2);
40008 {
40009 PyThreadState* __tstate = wxPyBeginAllowThreads();
40010 result = (bool)(arg1)->ScrollPages(arg2);
40011 wxPyEndAllowThreads(__tstate);
40012 if (PyErr_Occurred()) SWIG_fail;
40013 }
40014 {
40015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40016 }
40017 return resultobj;
40018 fail:
40019 return NULL;
40020 }
40021
40022
40023 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40024 PyObject *resultobj = 0;
40025 wxWindow *arg1 = (wxWindow *) 0 ;
40026 bool result;
40027 void *argp1 = 0 ;
40028 int res1 = 0 ;
40029 PyObject *swig_obj[1] ;
40030
40031 if (!args) SWIG_fail;
40032 swig_obj[0] = args;
40033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40034 if (!SWIG_IsOK(res1)) {
40035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40036 }
40037 arg1 = reinterpret_cast< wxWindow * >(argp1);
40038 {
40039 PyThreadState* __tstate = wxPyBeginAllowThreads();
40040 result = (bool)(arg1)->LineUp();
40041 wxPyEndAllowThreads(__tstate);
40042 if (PyErr_Occurred()) SWIG_fail;
40043 }
40044 {
40045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40046 }
40047 return resultobj;
40048 fail:
40049 return NULL;
40050 }
40051
40052
40053 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40054 PyObject *resultobj = 0;
40055 wxWindow *arg1 = (wxWindow *) 0 ;
40056 bool result;
40057 void *argp1 = 0 ;
40058 int res1 = 0 ;
40059 PyObject *swig_obj[1] ;
40060
40061 if (!args) SWIG_fail;
40062 swig_obj[0] = args;
40063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40064 if (!SWIG_IsOK(res1)) {
40065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40066 }
40067 arg1 = reinterpret_cast< wxWindow * >(argp1);
40068 {
40069 PyThreadState* __tstate = wxPyBeginAllowThreads();
40070 result = (bool)(arg1)->LineDown();
40071 wxPyEndAllowThreads(__tstate);
40072 if (PyErr_Occurred()) SWIG_fail;
40073 }
40074 {
40075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40076 }
40077 return resultobj;
40078 fail:
40079 return NULL;
40080 }
40081
40082
40083 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40084 PyObject *resultobj = 0;
40085 wxWindow *arg1 = (wxWindow *) 0 ;
40086 bool result;
40087 void *argp1 = 0 ;
40088 int res1 = 0 ;
40089 PyObject *swig_obj[1] ;
40090
40091 if (!args) SWIG_fail;
40092 swig_obj[0] = args;
40093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40094 if (!SWIG_IsOK(res1)) {
40095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40096 }
40097 arg1 = reinterpret_cast< wxWindow * >(argp1);
40098 {
40099 PyThreadState* __tstate = wxPyBeginAllowThreads();
40100 result = (bool)(arg1)->PageUp();
40101 wxPyEndAllowThreads(__tstate);
40102 if (PyErr_Occurred()) SWIG_fail;
40103 }
40104 {
40105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40106 }
40107 return resultobj;
40108 fail:
40109 return NULL;
40110 }
40111
40112
40113 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40114 PyObject *resultobj = 0;
40115 wxWindow *arg1 = (wxWindow *) 0 ;
40116 bool result;
40117 void *argp1 = 0 ;
40118 int res1 = 0 ;
40119 PyObject *swig_obj[1] ;
40120
40121 if (!args) SWIG_fail;
40122 swig_obj[0] = args;
40123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40124 if (!SWIG_IsOK(res1)) {
40125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40126 }
40127 arg1 = reinterpret_cast< wxWindow * >(argp1);
40128 {
40129 PyThreadState* __tstate = wxPyBeginAllowThreads();
40130 result = (bool)(arg1)->PageDown();
40131 wxPyEndAllowThreads(__tstate);
40132 if (PyErr_Occurred()) SWIG_fail;
40133 }
40134 {
40135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40136 }
40137 return resultobj;
40138 fail:
40139 return NULL;
40140 }
40141
40142
40143 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40144 PyObject *resultobj = 0;
40145 wxWindow *arg1 = (wxWindow *) 0 ;
40146 wxString *arg2 = 0 ;
40147 void *argp1 = 0 ;
40148 int res1 = 0 ;
40149 bool temp2 = false ;
40150 PyObject * obj0 = 0 ;
40151 PyObject * obj1 = 0 ;
40152 char * kwnames[] = {
40153 (char *) "self",(char *) "text", NULL
40154 };
40155
40156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40158 if (!SWIG_IsOK(res1)) {
40159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40160 }
40161 arg1 = reinterpret_cast< wxWindow * >(argp1);
40162 {
40163 arg2 = wxString_in_helper(obj1);
40164 if (arg2 == NULL) SWIG_fail;
40165 temp2 = true;
40166 }
40167 {
40168 PyThreadState* __tstate = wxPyBeginAllowThreads();
40169 (arg1)->SetHelpText((wxString const &)*arg2);
40170 wxPyEndAllowThreads(__tstate);
40171 if (PyErr_Occurred()) SWIG_fail;
40172 }
40173 resultobj = SWIG_Py_Void();
40174 {
40175 if (temp2)
40176 delete arg2;
40177 }
40178 return resultobj;
40179 fail:
40180 {
40181 if (temp2)
40182 delete arg2;
40183 }
40184 return NULL;
40185 }
40186
40187
40188 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40189 PyObject *resultobj = 0;
40190 wxWindow *arg1 = (wxWindow *) 0 ;
40191 wxString *arg2 = 0 ;
40192 void *argp1 = 0 ;
40193 int res1 = 0 ;
40194 bool temp2 = false ;
40195 PyObject * obj0 = 0 ;
40196 PyObject * obj1 = 0 ;
40197 char * kwnames[] = {
40198 (char *) "self",(char *) "text", NULL
40199 };
40200
40201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40203 if (!SWIG_IsOK(res1)) {
40204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40205 }
40206 arg1 = reinterpret_cast< wxWindow * >(argp1);
40207 {
40208 arg2 = wxString_in_helper(obj1);
40209 if (arg2 == NULL) SWIG_fail;
40210 temp2 = true;
40211 }
40212 {
40213 PyThreadState* __tstate = wxPyBeginAllowThreads();
40214 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40215 wxPyEndAllowThreads(__tstate);
40216 if (PyErr_Occurred()) SWIG_fail;
40217 }
40218 resultobj = SWIG_Py_Void();
40219 {
40220 if (temp2)
40221 delete arg2;
40222 }
40223 return resultobj;
40224 fail:
40225 {
40226 if (temp2)
40227 delete arg2;
40228 }
40229 return NULL;
40230 }
40231
40232
40233 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40234 PyObject *resultobj = 0;
40235 wxWindow *arg1 = (wxWindow *) 0 ;
40236 wxPoint *arg2 = 0 ;
40237 wxHelpEvent::Origin arg3 ;
40238 wxString result;
40239 void *argp1 = 0 ;
40240 int res1 = 0 ;
40241 wxPoint temp2 ;
40242 void *argp3 ;
40243 int res3 = 0 ;
40244 PyObject * obj0 = 0 ;
40245 PyObject * obj1 = 0 ;
40246 PyObject * obj2 = 0 ;
40247 char * kwnames[] = {
40248 (char *) "self",(char *) "pt",(char *) "origin", NULL
40249 };
40250
40251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40253 if (!SWIG_IsOK(res1)) {
40254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40255 }
40256 arg1 = reinterpret_cast< wxWindow * >(argp1);
40257 {
40258 arg2 = &temp2;
40259 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40260 }
40261 {
40262 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40263 if (!SWIG_IsOK(res3)) {
40264 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40265 }
40266 if (!argp3) {
40267 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40268 } else {
40269 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40270 arg3 = *temp;
40271 if (SWIG_IsNewObj(res3)) delete temp;
40272 }
40273 }
40274 {
40275 PyThreadState* __tstate = wxPyBeginAllowThreads();
40276 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40277 wxPyEndAllowThreads(__tstate);
40278 if (PyErr_Occurred()) SWIG_fail;
40279 }
40280 {
40281 #if wxUSE_UNICODE
40282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40283 #else
40284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40285 #endif
40286 }
40287 return resultobj;
40288 fail:
40289 return NULL;
40290 }
40291
40292
40293 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40294 PyObject *resultobj = 0;
40295 wxWindow *arg1 = (wxWindow *) 0 ;
40296 wxString result;
40297 void *argp1 = 0 ;
40298 int res1 = 0 ;
40299 PyObject *swig_obj[1] ;
40300
40301 if (!args) SWIG_fail;
40302 swig_obj[0] = args;
40303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40304 if (!SWIG_IsOK(res1)) {
40305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40306 }
40307 arg1 = reinterpret_cast< wxWindow * >(argp1);
40308 {
40309 PyThreadState* __tstate = wxPyBeginAllowThreads();
40310 result = ((wxWindow const *)arg1)->GetHelpText();
40311 wxPyEndAllowThreads(__tstate);
40312 if (PyErr_Occurred()) SWIG_fail;
40313 }
40314 {
40315 #if wxUSE_UNICODE
40316 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40317 #else
40318 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40319 #endif
40320 }
40321 return resultobj;
40322 fail:
40323 return NULL;
40324 }
40325
40326
40327 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40328 PyObject *resultobj = 0;
40329 wxWindow *arg1 = (wxWindow *) 0 ;
40330 wxString *arg2 = 0 ;
40331 void *argp1 = 0 ;
40332 int res1 = 0 ;
40333 bool temp2 = false ;
40334 PyObject * obj0 = 0 ;
40335 PyObject * obj1 = 0 ;
40336 char * kwnames[] = {
40337 (char *) "self",(char *) "tip", NULL
40338 };
40339
40340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40342 if (!SWIG_IsOK(res1)) {
40343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40344 }
40345 arg1 = reinterpret_cast< wxWindow * >(argp1);
40346 {
40347 arg2 = wxString_in_helper(obj1);
40348 if (arg2 == NULL) SWIG_fail;
40349 temp2 = true;
40350 }
40351 {
40352 PyThreadState* __tstate = wxPyBeginAllowThreads();
40353 (arg1)->SetToolTip((wxString const &)*arg2);
40354 wxPyEndAllowThreads(__tstate);
40355 if (PyErr_Occurred()) SWIG_fail;
40356 }
40357 resultobj = SWIG_Py_Void();
40358 {
40359 if (temp2)
40360 delete arg2;
40361 }
40362 return resultobj;
40363 fail:
40364 {
40365 if (temp2)
40366 delete arg2;
40367 }
40368 return NULL;
40369 }
40370
40371
40372 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40373 PyObject *resultobj = 0;
40374 wxWindow *arg1 = (wxWindow *) 0 ;
40375 wxToolTip *arg2 = (wxToolTip *) 0 ;
40376 void *argp1 = 0 ;
40377 int res1 = 0 ;
40378 int res2 = 0 ;
40379 PyObject * obj0 = 0 ;
40380 PyObject * obj1 = 0 ;
40381 char * kwnames[] = {
40382 (char *) "self",(char *) "tip", NULL
40383 };
40384
40385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40387 if (!SWIG_IsOK(res1)) {
40388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40389 }
40390 arg1 = reinterpret_cast< wxWindow * >(argp1);
40391 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40392 if (!SWIG_IsOK(res2)) {
40393 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40394 }
40395 {
40396 PyThreadState* __tstate = wxPyBeginAllowThreads();
40397 (arg1)->SetToolTip(arg2);
40398 wxPyEndAllowThreads(__tstate);
40399 if (PyErr_Occurred()) SWIG_fail;
40400 }
40401 resultobj = SWIG_Py_Void();
40402 return resultobj;
40403 fail:
40404 return NULL;
40405 }
40406
40407
40408 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40409 PyObject *resultobj = 0;
40410 wxWindow *arg1 = (wxWindow *) 0 ;
40411 wxToolTip *result = 0 ;
40412 void *argp1 = 0 ;
40413 int res1 = 0 ;
40414 PyObject *swig_obj[1] ;
40415
40416 if (!args) SWIG_fail;
40417 swig_obj[0] = args;
40418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40419 if (!SWIG_IsOK(res1)) {
40420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40421 }
40422 arg1 = reinterpret_cast< wxWindow * >(argp1);
40423 {
40424 PyThreadState* __tstate = wxPyBeginAllowThreads();
40425 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40426 wxPyEndAllowThreads(__tstate);
40427 if (PyErr_Occurred()) SWIG_fail;
40428 }
40429 {
40430 resultobj = wxPyMake_wxObject(result, (bool)0);
40431 }
40432 return resultobj;
40433 fail:
40434 return NULL;
40435 }
40436
40437
40438 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40439 PyObject *resultobj = 0;
40440 wxWindow *arg1 = (wxWindow *) 0 ;
40441 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40442 void *argp1 = 0 ;
40443 int res1 = 0 ;
40444 int res2 = 0 ;
40445 PyObject * obj0 = 0 ;
40446 PyObject * obj1 = 0 ;
40447 char * kwnames[] = {
40448 (char *) "self",(char *) "dropTarget", NULL
40449 };
40450
40451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40453 if (!SWIG_IsOK(res1)) {
40454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40455 }
40456 arg1 = reinterpret_cast< wxWindow * >(argp1);
40457 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40458 if (!SWIG_IsOK(res2)) {
40459 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40460 }
40461 {
40462 PyThreadState* __tstate = wxPyBeginAllowThreads();
40463 (arg1)->SetDropTarget(arg2);
40464 wxPyEndAllowThreads(__tstate);
40465 if (PyErr_Occurred()) SWIG_fail;
40466 }
40467 resultobj = SWIG_Py_Void();
40468 return resultobj;
40469 fail:
40470 return NULL;
40471 }
40472
40473
40474 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40475 PyObject *resultobj = 0;
40476 wxWindow *arg1 = (wxWindow *) 0 ;
40477 wxPyDropTarget *result = 0 ;
40478 void *argp1 = 0 ;
40479 int res1 = 0 ;
40480 PyObject *swig_obj[1] ;
40481
40482 if (!args) SWIG_fail;
40483 swig_obj[0] = args;
40484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40485 if (!SWIG_IsOK(res1)) {
40486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40487 }
40488 arg1 = reinterpret_cast< wxWindow * >(argp1);
40489 {
40490 PyThreadState* __tstate = wxPyBeginAllowThreads();
40491 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40492 wxPyEndAllowThreads(__tstate);
40493 if (PyErr_Occurred()) SWIG_fail;
40494 }
40495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40496 return resultobj;
40497 fail:
40498 return NULL;
40499 }
40500
40501
40502 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40503 PyObject *resultobj = 0;
40504 wxWindow *arg1 = (wxWindow *) 0 ;
40505 bool arg2 ;
40506 void *argp1 = 0 ;
40507 int res1 = 0 ;
40508 bool val2 ;
40509 int ecode2 = 0 ;
40510 PyObject * obj0 = 0 ;
40511 PyObject * obj1 = 0 ;
40512 char * kwnames[] = {
40513 (char *) "self",(char *) "accept", NULL
40514 };
40515
40516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40518 if (!SWIG_IsOK(res1)) {
40519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40520 }
40521 arg1 = reinterpret_cast< wxWindow * >(argp1);
40522 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40523 if (!SWIG_IsOK(ecode2)) {
40524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40525 }
40526 arg2 = static_cast< bool >(val2);
40527 {
40528 PyThreadState* __tstate = wxPyBeginAllowThreads();
40529 wxWindow_DragAcceptFiles(arg1,arg2);
40530 wxPyEndAllowThreads(__tstate);
40531 if (PyErr_Occurred()) SWIG_fail;
40532 }
40533 resultobj = SWIG_Py_Void();
40534 return resultobj;
40535 fail:
40536 return NULL;
40537 }
40538
40539
40540 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40541 PyObject *resultobj = 0;
40542 wxWindow *arg1 = (wxWindow *) 0 ;
40543 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40544 void *argp1 = 0 ;
40545 int res1 = 0 ;
40546 int res2 = 0 ;
40547 PyObject * obj0 = 0 ;
40548 PyObject * obj1 = 0 ;
40549 char * kwnames[] = {
40550 (char *) "self",(char *) "constraints", NULL
40551 };
40552
40553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40555 if (!SWIG_IsOK(res1)) {
40556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40557 }
40558 arg1 = reinterpret_cast< wxWindow * >(argp1);
40559 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40560 if (!SWIG_IsOK(res2)) {
40561 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40562 }
40563 {
40564 PyThreadState* __tstate = wxPyBeginAllowThreads();
40565 (arg1)->SetConstraints(arg2);
40566 wxPyEndAllowThreads(__tstate);
40567 if (PyErr_Occurred()) SWIG_fail;
40568 }
40569 resultobj = SWIG_Py_Void();
40570 return resultobj;
40571 fail:
40572 return NULL;
40573 }
40574
40575
40576 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40577 PyObject *resultobj = 0;
40578 wxWindow *arg1 = (wxWindow *) 0 ;
40579 wxLayoutConstraints *result = 0 ;
40580 void *argp1 = 0 ;
40581 int res1 = 0 ;
40582 PyObject *swig_obj[1] ;
40583
40584 if (!args) SWIG_fail;
40585 swig_obj[0] = args;
40586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40587 if (!SWIG_IsOK(res1)) {
40588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40589 }
40590 arg1 = reinterpret_cast< wxWindow * >(argp1);
40591 {
40592 PyThreadState* __tstate = wxPyBeginAllowThreads();
40593 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40594 wxPyEndAllowThreads(__tstate);
40595 if (PyErr_Occurred()) SWIG_fail;
40596 }
40597 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40598 return resultobj;
40599 fail:
40600 return NULL;
40601 }
40602
40603
40604 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40605 PyObject *resultobj = 0;
40606 wxWindow *arg1 = (wxWindow *) 0 ;
40607 bool arg2 ;
40608 void *argp1 = 0 ;
40609 int res1 = 0 ;
40610 bool val2 ;
40611 int ecode2 = 0 ;
40612 PyObject * obj0 = 0 ;
40613 PyObject * obj1 = 0 ;
40614 char * kwnames[] = {
40615 (char *) "self",(char *) "autoLayout", NULL
40616 };
40617
40618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40620 if (!SWIG_IsOK(res1)) {
40621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40622 }
40623 arg1 = reinterpret_cast< wxWindow * >(argp1);
40624 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40625 if (!SWIG_IsOK(ecode2)) {
40626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40627 }
40628 arg2 = static_cast< bool >(val2);
40629 {
40630 PyThreadState* __tstate = wxPyBeginAllowThreads();
40631 (arg1)->SetAutoLayout(arg2);
40632 wxPyEndAllowThreads(__tstate);
40633 if (PyErr_Occurred()) SWIG_fail;
40634 }
40635 resultobj = SWIG_Py_Void();
40636 return resultobj;
40637 fail:
40638 return NULL;
40639 }
40640
40641
40642 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40643 PyObject *resultobj = 0;
40644 wxWindow *arg1 = (wxWindow *) 0 ;
40645 bool result;
40646 void *argp1 = 0 ;
40647 int res1 = 0 ;
40648 PyObject *swig_obj[1] ;
40649
40650 if (!args) SWIG_fail;
40651 swig_obj[0] = args;
40652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40653 if (!SWIG_IsOK(res1)) {
40654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
40655 }
40656 arg1 = reinterpret_cast< wxWindow * >(argp1);
40657 {
40658 PyThreadState* __tstate = wxPyBeginAllowThreads();
40659 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
40660 wxPyEndAllowThreads(__tstate);
40661 if (PyErr_Occurred()) SWIG_fail;
40662 }
40663 {
40664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40665 }
40666 return resultobj;
40667 fail:
40668 return NULL;
40669 }
40670
40671
40672 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40673 PyObject *resultobj = 0;
40674 wxWindow *arg1 = (wxWindow *) 0 ;
40675 bool result;
40676 void *argp1 = 0 ;
40677 int res1 = 0 ;
40678 PyObject *swig_obj[1] ;
40679
40680 if (!args) SWIG_fail;
40681 swig_obj[0] = args;
40682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40683 if (!SWIG_IsOK(res1)) {
40684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
40685 }
40686 arg1 = reinterpret_cast< wxWindow * >(argp1);
40687 {
40688 PyThreadState* __tstate = wxPyBeginAllowThreads();
40689 result = (bool)(arg1)->Layout();
40690 wxPyEndAllowThreads(__tstate);
40691 if (PyErr_Occurred()) SWIG_fail;
40692 }
40693 {
40694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40695 }
40696 return resultobj;
40697 fail:
40698 return NULL;
40699 }
40700
40701
40702 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40703 PyObject *resultobj = 0;
40704 wxWindow *arg1 = (wxWindow *) 0 ;
40705 wxSizer *arg2 = (wxSizer *) 0 ;
40706 bool arg3 = (bool) true ;
40707 void *argp1 = 0 ;
40708 int res1 = 0 ;
40709 int res2 = 0 ;
40710 bool val3 ;
40711 int ecode3 = 0 ;
40712 PyObject * obj0 = 0 ;
40713 PyObject * obj1 = 0 ;
40714 PyObject * obj2 = 0 ;
40715 char * kwnames[] = {
40716 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40717 };
40718
40719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40721 if (!SWIG_IsOK(res1)) {
40722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40723 }
40724 arg1 = reinterpret_cast< wxWindow * >(argp1);
40725 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40726 if (!SWIG_IsOK(res2)) {
40727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40728 }
40729 if (obj2) {
40730 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40731 if (!SWIG_IsOK(ecode3)) {
40732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
40733 }
40734 arg3 = static_cast< bool >(val3);
40735 }
40736 {
40737 PyThreadState* __tstate = wxPyBeginAllowThreads();
40738 (arg1)->SetSizer(arg2,arg3);
40739 wxPyEndAllowThreads(__tstate);
40740 if (PyErr_Occurred()) SWIG_fail;
40741 }
40742 resultobj = SWIG_Py_Void();
40743 return resultobj;
40744 fail:
40745 return NULL;
40746 }
40747
40748
40749 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40750 PyObject *resultobj = 0;
40751 wxWindow *arg1 = (wxWindow *) 0 ;
40752 wxSizer *arg2 = (wxSizer *) 0 ;
40753 bool arg3 = (bool) true ;
40754 void *argp1 = 0 ;
40755 int res1 = 0 ;
40756 int res2 = 0 ;
40757 bool val3 ;
40758 int ecode3 = 0 ;
40759 PyObject * obj0 = 0 ;
40760 PyObject * obj1 = 0 ;
40761 PyObject * obj2 = 0 ;
40762 char * kwnames[] = {
40763 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40764 };
40765
40766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40768 if (!SWIG_IsOK(res1)) {
40769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
40770 }
40771 arg1 = reinterpret_cast< wxWindow * >(argp1);
40772 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40773 if (!SWIG_IsOK(res2)) {
40774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
40775 }
40776 if (obj2) {
40777 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40778 if (!SWIG_IsOK(ecode3)) {
40779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
40780 }
40781 arg3 = static_cast< bool >(val3);
40782 }
40783 {
40784 PyThreadState* __tstate = wxPyBeginAllowThreads();
40785 (arg1)->SetSizerAndFit(arg2,arg3);
40786 wxPyEndAllowThreads(__tstate);
40787 if (PyErr_Occurred()) SWIG_fail;
40788 }
40789 resultobj = SWIG_Py_Void();
40790 return resultobj;
40791 fail:
40792 return NULL;
40793 }
40794
40795
40796 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40797 PyObject *resultobj = 0;
40798 wxWindow *arg1 = (wxWindow *) 0 ;
40799 wxSizer *result = 0 ;
40800 void *argp1 = 0 ;
40801 int res1 = 0 ;
40802 PyObject *swig_obj[1] ;
40803
40804 if (!args) SWIG_fail;
40805 swig_obj[0] = args;
40806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40807 if (!SWIG_IsOK(res1)) {
40808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40809 }
40810 arg1 = reinterpret_cast< wxWindow * >(argp1);
40811 {
40812 PyThreadState* __tstate = wxPyBeginAllowThreads();
40813 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
40814 wxPyEndAllowThreads(__tstate);
40815 if (PyErr_Occurred()) SWIG_fail;
40816 }
40817 {
40818 resultobj = wxPyMake_wxObject(result, (bool)0);
40819 }
40820 return resultobj;
40821 fail:
40822 return NULL;
40823 }
40824
40825
40826 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40827 PyObject *resultobj = 0;
40828 wxWindow *arg1 = (wxWindow *) 0 ;
40829 wxSizer *arg2 = (wxSizer *) 0 ;
40830 void *argp1 = 0 ;
40831 int res1 = 0 ;
40832 void *argp2 = 0 ;
40833 int res2 = 0 ;
40834 PyObject * obj0 = 0 ;
40835 PyObject * obj1 = 0 ;
40836 char * kwnames[] = {
40837 (char *) "self",(char *) "sizer", NULL
40838 };
40839
40840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
40841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40842 if (!SWIG_IsOK(res1)) {
40843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40844 }
40845 arg1 = reinterpret_cast< wxWindow * >(argp1);
40846 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
40847 if (!SWIG_IsOK(res2)) {
40848 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40849 }
40850 arg2 = reinterpret_cast< wxSizer * >(argp2);
40851 {
40852 PyThreadState* __tstate = wxPyBeginAllowThreads();
40853 (arg1)->SetContainingSizer(arg2);
40854 wxPyEndAllowThreads(__tstate);
40855 if (PyErr_Occurred()) SWIG_fail;
40856 }
40857 resultobj = SWIG_Py_Void();
40858 return resultobj;
40859 fail:
40860 return NULL;
40861 }
40862
40863
40864 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40865 PyObject *resultobj = 0;
40866 wxWindow *arg1 = (wxWindow *) 0 ;
40867 wxSizer *result = 0 ;
40868 void *argp1 = 0 ;
40869 int res1 = 0 ;
40870 PyObject *swig_obj[1] ;
40871
40872 if (!args) SWIG_fail;
40873 swig_obj[0] = args;
40874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40875 if (!SWIG_IsOK(res1)) {
40876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40877 }
40878 arg1 = reinterpret_cast< wxWindow * >(argp1);
40879 {
40880 PyThreadState* __tstate = wxPyBeginAllowThreads();
40881 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
40882 wxPyEndAllowThreads(__tstate);
40883 if (PyErr_Occurred()) SWIG_fail;
40884 }
40885 {
40886 resultobj = wxPyMake_wxObject(result, (bool)0);
40887 }
40888 return resultobj;
40889 fail:
40890 return NULL;
40891 }
40892
40893
40894 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40895 PyObject *resultobj = 0;
40896 wxWindow *arg1 = (wxWindow *) 0 ;
40897 void *argp1 = 0 ;
40898 int res1 = 0 ;
40899 PyObject *swig_obj[1] ;
40900
40901 if (!args) SWIG_fail;
40902 swig_obj[0] = args;
40903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40904 if (!SWIG_IsOK(res1)) {
40905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
40906 }
40907 arg1 = reinterpret_cast< wxWindow * >(argp1);
40908 {
40909 PyThreadState* __tstate = wxPyBeginAllowThreads();
40910 (arg1)->InheritAttributes();
40911 wxPyEndAllowThreads(__tstate);
40912 if (PyErr_Occurred()) SWIG_fail;
40913 }
40914 resultobj = SWIG_Py_Void();
40915 return resultobj;
40916 fail:
40917 return NULL;
40918 }
40919
40920
40921 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40922 PyObject *resultobj = 0;
40923 wxWindow *arg1 = (wxWindow *) 0 ;
40924 bool result;
40925 void *argp1 = 0 ;
40926 int res1 = 0 ;
40927 PyObject *swig_obj[1] ;
40928
40929 if (!args) SWIG_fail;
40930 swig_obj[0] = args;
40931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40932 if (!SWIG_IsOK(res1)) {
40933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
40934 }
40935 arg1 = reinterpret_cast< wxWindow * >(argp1);
40936 {
40937 PyThreadState* __tstate = wxPyBeginAllowThreads();
40938 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
40939 wxPyEndAllowThreads(__tstate);
40940 if (PyErr_Occurred()) SWIG_fail;
40941 }
40942 {
40943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40944 }
40945 return resultobj;
40946 fail:
40947 return NULL;
40948 }
40949
40950
40951 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40952 PyObject *resultobj = 0;
40953 wxWindow *arg1 = (wxWindow *) 0 ;
40954 bool result;
40955 void *argp1 = 0 ;
40956 int res1 = 0 ;
40957 PyObject *swig_obj[1] ;
40958
40959 if (!args) SWIG_fail;
40960 swig_obj[0] = args;
40961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40962 if (!SWIG_IsOK(res1)) {
40963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
40964 }
40965 arg1 = reinterpret_cast< wxWindow * >(argp1);
40966 {
40967 PyThreadState* __tstate = wxPyBeginAllowThreads();
40968 result = (bool)(arg1)->CanSetTransparent();
40969 wxPyEndAllowThreads(__tstate);
40970 if (PyErr_Occurred()) SWIG_fail;
40971 }
40972 {
40973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40974 }
40975 return resultobj;
40976 fail:
40977 return NULL;
40978 }
40979
40980
40981 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40982 PyObject *resultobj = 0;
40983 wxWindow *arg1 = (wxWindow *) 0 ;
40984 byte arg2 ;
40985 bool result;
40986 void *argp1 = 0 ;
40987 int res1 = 0 ;
40988 unsigned char val2 ;
40989 int ecode2 = 0 ;
40990 PyObject * obj0 = 0 ;
40991 PyObject * obj1 = 0 ;
40992 char * kwnames[] = {
40993 (char *) "self",(char *) "alpha", NULL
40994 };
40995
40996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
40997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40998 if (!SWIG_IsOK(res1)) {
40999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41000 }
41001 arg1 = reinterpret_cast< wxWindow * >(argp1);
41002 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41003 if (!SWIG_IsOK(ecode2)) {
41004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41005 }
41006 arg2 = static_cast< byte >(val2);
41007 {
41008 PyThreadState* __tstate = wxPyBeginAllowThreads();
41009 result = (bool)(arg1)->SetTransparent(arg2);
41010 wxPyEndAllowThreads(__tstate);
41011 if (PyErr_Occurred()) SWIG_fail;
41012 }
41013 {
41014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41015 }
41016 return resultobj;
41017 fail:
41018 return NULL;
41019 }
41020
41021
41022 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41023 PyObject *obj;
41024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41025 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41026 return SWIG_Py_Void();
41027 }
41028
41029 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41030 return SWIG_Python_InitShadowInstance(args);
41031 }
41032
41033 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41034 PyObject *resultobj = 0;
41035 long arg1 ;
41036 wxWindow *arg2 = (wxWindow *) NULL ;
41037 wxWindow *result = 0 ;
41038 long val1 ;
41039 int ecode1 = 0 ;
41040 void *argp2 = 0 ;
41041 int res2 = 0 ;
41042 PyObject * obj0 = 0 ;
41043 PyObject * obj1 = 0 ;
41044 char * kwnames[] = {
41045 (char *) "id",(char *) "parent", NULL
41046 };
41047
41048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41049 ecode1 = SWIG_AsVal_long(obj0, &val1);
41050 if (!SWIG_IsOK(ecode1)) {
41051 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41052 }
41053 arg1 = static_cast< long >(val1);
41054 if (obj1) {
41055 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41056 if (!SWIG_IsOK(res2)) {
41057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41058 }
41059 arg2 = reinterpret_cast< wxWindow * >(argp2);
41060 }
41061 {
41062 if (!wxPyCheckForApp()) SWIG_fail;
41063 PyThreadState* __tstate = wxPyBeginAllowThreads();
41064 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41065 wxPyEndAllowThreads(__tstate);
41066 if (PyErr_Occurred()) SWIG_fail;
41067 }
41068 {
41069 resultobj = wxPyMake_wxObject(result, 0);
41070 }
41071 return resultobj;
41072 fail:
41073 return NULL;
41074 }
41075
41076
41077 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41078 PyObject *resultobj = 0;
41079 wxString *arg1 = 0 ;
41080 wxWindow *arg2 = (wxWindow *) NULL ;
41081 wxWindow *result = 0 ;
41082 bool temp1 = false ;
41083 void *argp2 = 0 ;
41084 int res2 = 0 ;
41085 PyObject * obj0 = 0 ;
41086 PyObject * obj1 = 0 ;
41087 char * kwnames[] = {
41088 (char *) "name",(char *) "parent", NULL
41089 };
41090
41091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41092 {
41093 arg1 = wxString_in_helper(obj0);
41094 if (arg1 == NULL) SWIG_fail;
41095 temp1 = true;
41096 }
41097 if (obj1) {
41098 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41099 if (!SWIG_IsOK(res2)) {
41100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41101 }
41102 arg2 = reinterpret_cast< wxWindow * >(argp2);
41103 }
41104 {
41105 if (!wxPyCheckForApp()) SWIG_fail;
41106 PyThreadState* __tstate = wxPyBeginAllowThreads();
41107 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41108 wxPyEndAllowThreads(__tstate);
41109 if (PyErr_Occurred()) SWIG_fail;
41110 }
41111 {
41112 resultobj = wxPyMake_wxObject(result, 0);
41113 }
41114 {
41115 if (temp1)
41116 delete arg1;
41117 }
41118 return resultobj;
41119 fail:
41120 {
41121 if (temp1)
41122 delete arg1;
41123 }
41124 return NULL;
41125 }
41126
41127
41128 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41129 PyObject *resultobj = 0;
41130 wxString *arg1 = 0 ;
41131 wxWindow *arg2 = (wxWindow *) NULL ;
41132 wxWindow *result = 0 ;
41133 bool temp1 = false ;
41134 void *argp2 = 0 ;
41135 int res2 = 0 ;
41136 PyObject * obj0 = 0 ;
41137 PyObject * obj1 = 0 ;
41138 char * kwnames[] = {
41139 (char *) "label",(char *) "parent", NULL
41140 };
41141
41142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41143 {
41144 arg1 = wxString_in_helper(obj0);
41145 if (arg1 == NULL) SWIG_fail;
41146 temp1 = true;
41147 }
41148 if (obj1) {
41149 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41150 if (!SWIG_IsOK(res2)) {
41151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41152 }
41153 arg2 = reinterpret_cast< wxWindow * >(argp2);
41154 }
41155 {
41156 if (!wxPyCheckForApp()) SWIG_fail;
41157 PyThreadState* __tstate = wxPyBeginAllowThreads();
41158 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41159 wxPyEndAllowThreads(__tstate);
41160 if (PyErr_Occurred()) SWIG_fail;
41161 }
41162 {
41163 resultobj = wxPyMake_wxObject(result, 0);
41164 }
41165 {
41166 if (temp1)
41167 delete arg1;
41168 }
41169 return resultobj;
41170 fail:
41171 {
41172 if (temp1)
41173 delete arg1;
41174 }
41175 return NULL;
41176 }
41177
41178
41179 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41180 PyObject *resultobj = 0;
41181 wxWindow *arg1 = (wxWindow *) 0 ;
41182 unsigned long arg2 ;
41183 wxWindow *result = 0 ;
41184 void *argp1 = 0 ;
41185 int res1 = 0 ;
41186 unsigned long val2 ;
41187 int ecode2 = 0 ;
41188 PyObject * obj0 = 0 ;
41189 PyObject * obj1 = 0 ;
41190 char * kwnames[] = {
41191 (char *) "parent",(char *) "_hWnd", NULL
41192 };
41193
41194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41196 if (!SWIG_IsOK(res1)) {
41197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41198 }
41199 arg1 = reinterpret_cast< wxWindow * >(argp1);
41200 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41201 if (!SWIG_IsOK(ecode2)) {
41202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41203 }
41204 arg2 = static_cast< unsigned long >(val2);
41205 {
41206 PyThreadState* __tstate = wxPyBeginAllowThreads();
41207 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41208 wxPyEndAllowThreads(__tstate);
41209 if (PyErr_Occurred()) SWIG_fail;
41210 }
41211 {
41212 resultobj = wxPyMake_wxObject(result, 0);
41213 }
41214 return resultobj;
41215 fail:
41216 return NULL;
41217 }
41218
41219
41220 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41221 PyObject *resultobj = 0;
41222 PyObject *result = 0 ;
41223
41224 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41225 {
41226 PyThreadState* __tstate = wxPyBeginAllowThreads();
41227 result = (PyObject *)GetTopLevelWindows();
41228 wxPyEndAllowThreads(__tstate);
41229 if (PyErr_Occurred()) SWIG_fail;
41230 }
41231 resultobj = result;
41232 return resultobj;
41233 fail:
41234 return NULL;
41235 }
41236
41237
41238 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41239 PyObject *resultobj = 0;
41240 wxValidator *result = 0 ;
41241
41242 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41243 {
41244 PyThreadState* __tstate = wxPyBeginAllowThreads();
41245 result = (wxValidator *)new wxValidator();
41246 wxPyEndAllowThreads(__tstate);
41247 if (PyErr_Occurred()) SWIG_fail;
41248 }
41249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41250 return resultobj;
41251 fail:
41252 return NULL;
41253 }
41254
41255
41256 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41257 PyObject *resultobj = 0;
41258 wxValidator *arg1 = (wxValidator *) 0 ;
41259 wxValidator *result = 0 ;
41260 void *argp1 = 0 ;
41261 int res1 = 0 ;
41262 PyObject *swig_obj[1] ;
41263
41264 if (!args) SWIG_fail;
41265 swig_obj[0] = args;
41266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41267 if (!SWIG_IsOK(res1)) {
41268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41269 }
41270 arg1 = reinterpret_cast< wxValidator * >(argp1);
41271 {
41272 PyThreadState* __tstate = wxPyBeginAllowThreads();
41273 result = (wxValidator *)(arg1)->Clone();
41274 wxPyEndAllowThreads(__tstate);
41275 if (PyErr_Occurred()) SWIG_fail;
41276 }
41277 {
41278 resultobj = wxPyMake_wxObject(result, 0);
41279 }
41280 return resultobj;
41281 fail:
41282 return NULL;
41283 }
41284
41285
41286 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41287 PyObject *resultobj = 0;
41288 wxValidator *arg1 = (wxValidator *) 0 ;
41289 wxWindow *arg2 = (wxWindow *) 0 ;
41290 bool result;
41291 void *argp1 = 0 ;
41292 int res1 = 0 ;
41293 void *argp2 = 0 ;
41294 int res2 = 0 ;
41295 PyObject * obj0 = 0 ;
41296 PyObject * obj1 = 0 ;
41297 char * kwnames[] = {
41298 (char *) "self",(char *) "parent", NULL
41299 };
41300
41301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41303 if (!SWIG_IsOK(res1)) {
41304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41305 }
41306 arg1 = reinterpret_cast< wxValidator * >(argp1);
41307 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41308 if (!SWIG_IsOK(res2)) {
41309 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41310 }
41311 arg2 = reinterpret_cast< wxWindow * >(argp2);
41312 {
41313 PyThreadState* __tstate = wxPyBeginAllowThreads();
41314 result = (bool)(arg1)->Validate(arg2);
41315 wxPyEndAllowThreads(__tstate);
41316 if (PyErr_Occurred()) SWIG_fail;
41317 }
41318 {
41319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41320 }
41321 return resultobj;
41322 fail:
41323 return NULL;
41324 }
41325
41326
41327 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41328 PyObject *resultobj = 0;
41329 wxValidator *arg1 = (wxValidator *) 0 ;
41330 bool result;
41331 void *argp1 = 0 ;
41332 int res1 = 0 ;
41333 PyObject *swig_obj[1] ;
41334
41335 if (!args) SWIG_fail;
41336 swig_obj[0] = args;
41337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41338 if (!SWIG_IsOK(res1)) {
41339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41340 }
41341 arg1 = reinterpret_cast< wxValidator * >(argp1);
41342 {
41343 PyThreadState* __tstate = wxPyBeginAllowThreads();
41344 result = (bool)(arg1)->TransferToWindow();
41345 wxPyEndAllowThreads(__tstate);
41346 if (PyErr_Occurred()) SWIG_fail;
41347 }
41348 {
41349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41350 }
41351 return resultobj;
41352 fail:
41353 return NULL;
41354 }
41355
41356
41357 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41358 PyObject *resultobj = 0;
41359 wxValidator *arg1 = (wxValidator *) 0 ;
41360 bool result;
41361 void *argp1 = 0 ;
41362 int res1 = 0 ;
41363 PyObject *swig_obj[1] ;
41364
41365 if (!args) SWIG_fail;
41366 swig_obj[0] = args;
41367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41368 if (!SWIG_IsOK(res1)) {
41369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41370 }
41371 arg1 = reinterpret_cast< wxValidator * >(argp1);
41372 {
41373 PyThreadState* __tstate = wxPyBeginAllowThreads();
41374 result = (bool)(arg1)->TransferFromWindow();
41375 wxPyEndAllowThreads(__tstate);
41376 if (PyErr_Occurred()) SWIG_fail;
41377 }
41378 {
41379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41380 }
41381 return resultobj;
41382 fail:
41383 return NULL;
41384 }
41385
41386
41387 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41388 PyObject *resultobj = 0;
41389 wxValidator *arg1 = (wxValidator *) 0 ;
41390 wxWindow *result = 0 ;
41391 void *argp1 = 0 ;
41392 int res1 = 0 ;
41393 PyObject *swig_obj[1] ;
41394
41395 if (!args) SWIG_fail;
41396 swig_obj[0] = args;
41397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41398 if (!SWIG_IsOK(res1)) {
41399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41400 }
41401 arg1 = reinterpret_cast< wxValidator * >(argp1);
41402 {
41403 PyThreadState* __tstate = wxPyBeginAllowThreads();
41404 result = (wxWindow *)(arg1)->GetWindow();
41405 wxPyEndAllowThreads(__tstate);
41406 if (PyErr_Occurred()) SWIG_fail;
41407 }
41408 {
41409 resultobj = wxPyMake_wxObject(result, 0);
41410 }
41411 return resultobj;
41412 fail:
41413 return NULL;
41414 }
41415
41416
41417 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41418 PyObject *resultobj = 0;
41419 wxValidator *arg1 = (wxValidator *) 0 ;
41420 wxWindow *arg2 = (wxWindow *) 0 ;
41421 void *argp1 = 0 ;
41422 int res1 = 0 ;
41423 void *argp2 = 0 ;
41424 int res2 = 0 ;
41425 PyObject * obj0 = 0 ;
41426 PyObject * obj1 = 0 ;
41427 char * kwnames[] = {
41428 (char *) "self",(char *) "window", NULL
41429 };
41430
41431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41433 if (!SWIG_IsOK(res1)) {
41434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41435 }
41436 arg1 = reinterpret_cast< wxValidator * >(argp1);
41437 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41438 if (!SWIG_IsOK(res2)) {
41439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41440 }
41441 arg2 = reinterpret_cast< wxWindow * >(argp2);
41442 {
41443 PyThreadState* __tstate = wxPyBeginAllowThreads();
41444 (arg1)->SetWindow(arg2);
41445 wxPyEndAllowThreads(__tstate);
41446 if (PyErr_Occurred()) SWIG_fail;
41447 }
41448 resultobj = SWIG_Py_Void();
41449 return resultobj;
41450 fail:
41451 return NULL;
41452 }
41453
41454
41455 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41456 PyObject *resultobj = 0;
41457 bool result;
41458
41459 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41460 {
41461 PyThreadState* __tstate = wxPyBeginAllowThreads();
41462 result = (bool)wxValidator::IsSilent();
41463 wxPyEndAllowThreads(__tstate);
41464 if (PyErr_Occurred()) SWIG_fail;
41465 }
41466 {
41467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41468 }
41469 return resultobj;
41470 fail:
41471 return NULL;
41472 }
41473
41474
41475 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41476 PyObject *resultobj = 0;
41477 int arg1 = (int) true ;
41478 int val1 ;
41479 int ecode1 = 0 ;
41480 PyObject * obj0 = 0 ;
41481 char * kwnames[] = {
41482 (char *) "doIt", NULL
41483 };
41484
41485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41486 if (obj0) {
41487 ecode1 = SWIG_AsVal_int(obj0, &val1);
41488 if (!SWIG_IsOK(ecode1)) {
41489 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41490 }
41491 arg1 = static_cast< int >(val1);
41492 }
41493 {
41494 PyThreadState* __tstate = wxPyBeginAllowThreads();
41495 wxValidator::SetBellOnError(arg1);
41496 wxPyEndAllowThreads(__tstate);
41497 if (PyErr_Occurred()) SWIG_fail;
41498 }
41499 resultobj = SWIG_Py_Void();
41500 return resultobj;
41501 fail:
41502 return NULL;
41503 }
41504
41505
41506 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41507 PyObject *obj;
41508 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41509 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41510 return SWIG_Py_Void();
41511 }
41512
41513 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41514 return SWIG_Python_InitShadowInstance(args);
41515 }
41516
41517 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41518 PyObject *resultobj = 0;
41519 wxPyValidator *result = 0 ;
41520
41521 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41522 {
41523 PyThreadState* __tstate = wxPyBeginAllowThreads();
41524 result = (wxPyValidator *)new wxPyValidator();
41525 wxPyEndAllowThreads(__tstate);
41526 if (PyErr_Occurred()) SWIG_fail;
41527 }
41528 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41529 return resultobj;
41530 fail:
41531 return NULL;
41532 }
41533
41534
41535 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41536 PyObject *resultobj = 0;
41537 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41538 PyObject *arg2 = (PyObject *) 0 ;
41539 PyObject *arg3 = (PyObject *) 0 ;
41540 int arg4 = (int) 1 ;
41541 void *argp1 = 0 ;
41542 int res1 = 0 ;
41543 int val4 ;
41544 int ecode4 = 0 ;
41545 PyObject * obj0 = 0 ;
41546 PyObject * obj1 = 0 ;
41547 PyObject * obj2 = 0 ;
41548 PyObject * obj3 = 0 ;
41549 char * kwnames[] = {
41550 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41551 };
41552
41553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41555 if (!SWIG_IsOK(res1)) {
41556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41557 }
41558 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41559 arg2 = obj1;
41560 arg3 = obj2;
41561 if (obj3) {
41562 ecode4 = SWIG_AsVal_int(obj3, &val4);
41563 if (!SWIG_IsOK(ecode4)) {
41564 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41565 }
41566 arg4 = static_cast< int >(val4);
41567 }
41568 {
41569 PyThreadState* __tstate = wxPyBeginAllowThreads();
41570 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41571 wxPyEndAllowThreads(__tstate);
41572 if (PyErr_Occurred()) SWIG_fail;
41573 }
41574 resultobj = SWIG_Py_Void();
41575 return resultobj;
41576 fail:
41577 return NULL;
41578 }
41579
41580
41581 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41582 PyObject *obj;
41583 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41584 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41585 return SWIG_Py_Void();
41586 }
41587
41588 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41589 return SWIG_Python_InitShadowInstance(args);
41590 }
41591
41592 SWIGINTERN int DefaultValidator_set(PyObject *) {
41593 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41594 return 1;
41595 }
41596
41597
41598 SWIGINTERN PyObject *DefaultValidator_get(void) {
41599 PyObject *pyobj = 0;
41600
41601 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41602 return pyobj;
41603 }
41604
41605
41606 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41607 PyObject *resultobj = 0;
41608 wxString const &arg1_defvalue = wxPyEmptyString ;
41609 wxString *arg1 = (wxString *) &arg1_defvalue ;
41610 long arg2 = (long) 0 ;
41611 wxMenu *result = 0 ;
41612 bool temp1 = false ;
41613 long val2 ;
41614 int ecode2 = 0 ;
41615 PyObject * obj0 = 0 ;
41616 PyObject * obj1 = 0 ;
41617 char * kwnames[] = {
41618 (char *) "title",(char *) "style", NULL
41619 };
41620
41621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41622 if (obj0) {
41623 {
41624 arg1 = wxString_in_helper(obj0);
41625 if (arg1 == NULL) SWIG_fail;
41626 temp1 = true;
41627 }
41628 }
41629 if (obj1) {
41630 ecode2 = SWIG_AsVal_long(obj1, &val2);
41631 if (!SWIG_IsOK(ecode2)) {
41632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
41633 }
41634 arg2 = static_cast< long >(val2);
41635 }
41636 {
41637 if (!wxPyCheckForApp()) SWIG_fail;
41638 PyThreadState* __tstate = wxPyBeginAllowThreads();
41639 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
41640 wxPyEndAllowThreads(__tstate);
41641 if (PyErr_Occurred()) SWIG_fail;
41642 }
41643 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
41644 {
41645 if (temp1)
41646 delete arg1;
41647 }
41648 return resultobj;
41649 fail:
41650 {
41651 if (temp1)
41652 delete arg1;
41653 }
41654 return NULL;
41655 }
41656
41657
41658 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41659 PyObject *resultobj = 0;
41660 wxMenu *arg1 = (wxMenu *) 0 ;
41661 int arg2 ;
41662 wxString const &arg3_defvalue = wxPyEmptyString ;
41663 wxString *arg3 = (wxString *) &arg3_defvalue ;
41664 wxString const &arg4_defvalue = wxPyEmptyString ;
41665 wxString *arg4 = (wxString *) &arg4_defvalue ;
41666 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41667 wxMenuItem *result = 0 ;
41668 void *argp1 = 0 ;
41669 int res1 = 0 ;
41670 int val2 ;
41671 int ecode2 = 0 ;
41672 bool temp3 = false ;
41673 bool temp4 = false ;
41674 int val5 ;
41675 int ecode5 = 0 ;
41676 PyObject * obj0 = 0 ;
41677 PyObject * obj1 = 0 ;
41678 PyObject * obj2 = 0 ;
41679 PyObject * obj3 = 0 ;
41680 PyObject * obj4 = 0 ;
41681 char * kwnames[] = {
41682 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
41683 };
41684
41685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41687 if (!SWIG_IsOK(res1)) {
41688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
41689 }
41690 arg1 = reinterpret_cast< wxMenu * >(argp1);
41691 ecode2 = SWIG_AsVal_int(obj1, &val2);
41692 if (!SWIG_IsOK(ecode2)) {
41693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
41694 }
41695 arg2 = static_cast< int >(val2);
41696 if (obj2) {
41697 {
41698 arg3 = wxString_in_helper(obj2);
41699 if (arg3 == NULL) SWIG_fail;
41700 temp3 = true;
41701 }
41702 }
41703 if (obj3) {
41704 {
41705 arg4 = wxString_in_helper(obj3);
41706 if (arg4 == NULL) SWIG_fail;
41707 temp4 = true;
41708 }
41709 }
41710 if (obj4) {
41711 ecode5 = SWIG_AsVal_int(obj4, &val5);
41712 if (!SWIG_IsOK(ecode5)) {
41713 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
41714 }
41715 arg5 = static_cast< wxItemKind >(val5);
41716 }
41717 {
41718 PyThreadState* __tstate = wxPyBeginAllowThreads();
41719 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
41720 wxPyEndAllowThreads(__tstate);
41721 if (PyErr_Occurred()) SWIG_fail;
41722 }
41723 {
41724 resultobj = wxPyMake_wxObject(result, (bool)0);
41725 }
41726 {
41727 if (temp3)
41728 delete arg3;
41729 }
41730 {
41731 if (temp4)
41732 delete arg4;
41733 }
41734 return resultobj;
41735 fail:
41736 {
41737 if (temp3)
41738 delete arg3;
41739 }
41740 {
41741 if (temp4)
41742 delete arg4;
41743 }
41744 return NULL;
41745 }
41746
41747
41748 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41749 PyObject *resultobj = 0;
41750 wxMenu *arg1 = (wxMenu *) 0 ;
41751 wxMenuItem *result = 0 ;
41752 void *argp1 = 0 ;
41753 int res1 = 0 ;
41754 PyObject *swig_obj[1] ;
41755
41756 if (!args) SWIG_fail;
41757 swig_obj[0] = args;
41758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41759 if (!SWIG_IsOK(res1)) {
41760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
41761 }
41762 arg1 = reinterpret_cast< wxMenu * >(argp1);
41763 {
41764 PyThreadState* __tstate = wxPyBeginAllowThreads();
41765 result = (wxMenuItem *)(arg1)->AppendSeparator();
41766 wxPyEndAllowThreads(__tstate);
41767 if (PyErr_Occurred()) SWIG_fail;
41768 }
41769 {
41770 resultobj = wxPyMake_wxObject(result, (bool)0);
41771 }
41772 return resultobj;
41773 fail:
41774 return NULL;
41775 }
41776
41777
41778 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41779 PyObject *resultobj = 0;
41780 wxMenu *arg1 = (wxMenu *) 0 ;
41781 int arg2 ;
41782 wxString *arg3 = 0 ;
41783 wxString const &arg4_defvalue = wxPyEmptyString ;
41784 wxString *arg4 = (wxString *) &arg4_defvalue ;
41785 wxMenuItem *result = 0 ;
41786 void *argp1 = 0 ;
41787 int res1 = 0 ;
41788 int val2 ;
41789 int ecode2 = 0 ;
41790 bool temp3 = false ;
41791 bool temp4 = false ;
41792 PyObject * obj0 = 0 ;
41793 PyObject * obj1 = 0 ;
41794 PyObject * obj2 = 0 ;
41795 PyObject * obj3 = 0 ;
41796 char * kwnames[] = {
41797 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41798 };
41799
41800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41802 if (!SWIG_IsOK(res1)) {
41803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41804 }
41805 arg1 = reinterpret_cast< wxMenu * >(argp1);
41806 ecode2 = SWIG_AsVal_int(obj1, &val2);
41807 if (!SWIG_IsOK(ecode2)) {
41808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
41809 }
41810 arg2 = static_cast< int >(val2);
41811 {
41812 arg3 = wxString_in_helper(obj2);
41813 if (arg3 == NULL) SWIG_fail;
41814 temp3 = true;
41815 }
41816 if (obj3) {
41817 {
41818 arg4 = wxString_in_helper(obj3);
41819 if (arg4 == NULL) SWIG_fail;
41820 temp4 = true;
41821 }
41822 }
41823 {
41824 PyThreadState* __tstate = wxPyBeginAllowThreads();
41825 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41826 wxPyEndAllowThreads(__tstate);
41827 if (PyErr_Occurred()) SWIG_fail;
41828 }
41829 {
41830 resultobj = wxPyMake_wxObject(result, (bool)0);
41831 }
41832 {
41833 if (temp3)
41834 delete arg3;
41835 }
41836 {
41837 if (temp4)
41838 delete arg4;
41839 }
41840 return resultobj;
41841 fail:
41842 {
41843 if (temp3)
41844 delete arg3;
41845 }
41846 {
41847 if (temp4)
41848 delete arg4;
41849 }
41850 return NULL;
41851 }
41852
41853
41854 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41855 PyObject *resultobj = 0;
41856 wxMenu *arg1 = (wxMenu *) 0 ;
41857 int arg2 ;
41858 wxString *arg3 = 0 ;
41859 wxString const &arg4_defvalue = wxPyEmptyString ;
41860 wxString *arg4 = (wxString *) &arg4_defvalue ;
41861 wxMenuItem *result = 0 ;
41862 void *argp1 = 0 ;
41863 int res1 = 0 ;
41864 int val2 ;
41865 int ecode2 = 0 ;
41866 bool temp3 = false ;
41867 bool temp4 = false ;
41868 PyObject * obj0 = 0 ;
41869 PyObject * obj1 = 0 ;
41870 PyObject * obj2 = 0 ;
41871 PyObject * obj3 = 0 ;
41872 char * kwnames[] = {
41873 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41874 };
41875
41876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41878 if (!SWIG_IsOK(res1)) {
41879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41880 }
41881 arg1 = reinterpret_cast< wxMenu * >(argp1);
41882 ecode2 = SWIG_AsVal_int(obj1, &val2);
41883 if (!SWIG_IsOK(ecode2)) {
41884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
41885 }
41886 arg2 = static_cast< int >(val2);
41887 {
41888 arg3 = wxString_in_helper(obj2);
41889 if (arg3 == NULL) SWIG_fail;
41890 temp3 = true;
41891 }
41892 if (obj3) {
41893 {
41894 arg4 = wxString_in_helper(obj3);
41895 if (arg4 == NULL) SWIG_fail;
41896 temp4 = true;
41897 }
41898 }
41899 {
41900 PyThreadState* __tstate = wxPyBeginAllowThreads();
41901 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41902 wxPyEndAllowThreads(__tstate);
41903 if (PyErr_Occurred()) SWIG_fail;
41904 }
41905 {
41906 resultobj = wxPyMake_wxObject(result, (bool)0);
41907 }
41908 {
41909 if (temp3)
41910 delete arg3;
41911 }
41912 {
41913 if (temp4)
41914 delete arg4;
41915 }
41916 return resultobj;
41917 fail:
41918 {
41919 if (temp3)
41920 delete arg3;
41921 }
41922 {
41923 if (temp4)
41924 delete arg4;
41925 }
41926 return NULL;
41927 }
41928
41929
41930 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41931 PyObject *resultobj = 0;
41932 wxMenu *arg1 = (wxMenu *) 0 ;
41933 int arg2 ;
41934 wxString *arg3 = 0 ;
41935 wxMenu *arg4 = (wxMenu *) 0 ;
41936 wxString const &arg5_defvalue = wxPyEmptyString ;
41937 wxString *arg5 = (wxString *) &arg5_defvalue ;
41938 wxMenuItem *result = 0 ;
41939 void *argp1 = 0 ;
41940 int res1 = 0 ;
41941 int val2 ;
41942 int ecode2 = 0 ;
41943 bool temp3 = false ;
41944 void *argp4 = 0 ;
41945 int res4 = 0 ;
41946 bool temp5 = false ;
41947 PyObject * obj0 = 0 ;
41948 PyObject * obj1 = 0 ;
41949 PyObject * obj2 = 0 ;
41950 PyObject * obj3 = 0 ;
41951 PyObject * obj4 = 0 ;
41952 char * kwnames[] = {
41953 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
41954 };
41955
41956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41958 if (!SWIG_IsOK(res1)) {
41959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
41960 }
41961 arg1 = reinterpret_cast< wxMenu * >(argp1);
41962 ecode2 = SWIG_AsVal_int(obj1, &val2);
41963 if (!SWIG_IsOK(ecode2)) {
41964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
41965 }
41966 arg2 = static_cast< int >(val2);
41967 {
41968 arg3 = wxString_in_helper(obj2);
41969 if (arg3 == NULL) SWIG_fail;
41970 temp3 = true;
41971 }
41972 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
41973 if (!SWIG_IsOK(res4)) {
41974 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
41975 }
41976 arg4 = reinterpret_cast< wxMenu * >(argp4);
41977 if (obj4) {
41978 {
41979 arg5 = wxString_in_helper(obj4);
41980 if (arg5 == NULL) SWIG_fail;
41981 temp5 = true;
41982 }
41983 }
41984 {
41985 PyThreadState* __tstate = wxPyBeginAllowThreads();
41986 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
41987 wxPyEndAllowThreads(__tstate);
41988 if (PyErr_Occurred()) SWIG_fail;
41989 }
41990 {
41991 resultobj = wxPyMake_wxObject(result, (bool)0);
41992 }
41993 {
41994 if (temp3)
41995 delete arg3;
41996 }
41997 {
41998 if (temp5)
41999 delete arg5;
42000 }
42001 return resultobj;
42002 fail:
42003 {
42004 if (temp3)
42005 delete arg3;
42006 }
42007 {
42008 if (temp5)
42009 delete arg5;
42010 }
42011 return NULL;
42012 }
42013
42014
42015 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42016 PyObject *resultobj = 0;
42017 wxMenu *arg1 = (wxMenu *) 0 ;
42018 wxMenu *arg2 = (wxMenu *) 0 ;
42019 wxString *arg3 = 0 ;
42020 wxString const &arg4_defvalue = wxPyEmptyString ;
42021 wxString *arg4 = (wxString *) &arg4_defvalue ;
42022 wxMenuItem *result = 0 ;
42023 void *argp1 = 0 ;
42024 int res1 = 0 ;
42025 void *argp2 = 0 ;
42026 int res2 = 0 ;
42027 bool temp3 = false ;
42028 bool temp4 = false ;
42029 PyObject * obj0 = 0 ;
42030 PyObject * obj1 = 0 ;
42031 PyObject * obj2 = 0 ;
42032 PyObject * obj3 = 0 ;
42033 char * kwnames[] = {
42034 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42035 };
42036
42037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42039 if (!SWIG_IsOK(res1)) {
42040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42041 }
42042 arg1 = reinterpret_cast< wxMenu * >(argp1);
42043 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42044 if (!SWIG_IsOK(res2)) {
42045 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42046 }
42047 arg2 = reinterpret_cast< wxMenu * >(argp2);
42048 {
42049 arg3 = wxString_in_helper(obj2);
42050 if (arg3 == NULL) SWIG_fail;
42051 temp3 = true;
42052 }
42053 if (obj3) {
42054 {
42055 arg4 = wxString_in_helper(obj3);
42056 if (arg4 == NULL) SWIG_fail;
42057 temp4 = true;
42058 }
42059 }
42060 {
42061 PyThreadState* __tstate = wxPyBeginAllowThreads();
42062 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42063 wxPyEndAllowThreads(__tstate);
42064 if (PyErr_Occurred()) SWIG_fail;
42065 }
42066 {
42067 resultobj = wxPyMake_wxObject(result, (bool)0);
42068 }
42069 {
42070 if (temp3)
42071 delete arg3;
42072 }
42073 {
42074 if (temp4)
42075 delete arg4;
42076 }
42077 return resultobj;
42078 fail:
42079 {
42080 if (temp3)
42081 delete arg3;
42082 }
42083 {
42084 if (temp4)
42085 delete arg4;
42086 }
42087 return NULL;
42088 }
42089
42090
42091 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42092 PyObject *resultobj = 0;
42093 wxMenu *arg1 = (wxMenu *) 0 ;
42094 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42095 wxMenuItem *result = 0 ;
42096 void *argp1 = 0 ;
42097 int res1 = 0 ;
42098 int res2 = 0 ;
42099 PyObject * obj0 = 0 ;
42100 PyObject * obj1 = 0 ;
42101 char * kwnames[] = {
42102 (char *) "self",(char *) "item", NULL
42103 };
42104
42105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42107 if (!SWIG_IsOK(res1)) {
42108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42109 }
42110 arg1 = reinterpret_cast< wxMenu * >(argp1);
42111 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42112 if (!SWIG_IsOK(res2)) {
42113 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42114 }
42115 {
42116 PyThreadState* __tstate = wxPyBeginAllowThreads();
42117 result = (wxMenuItem *)(arg1)->Append(arg2);
42118 wxPyEndAllowThreads(__tstate);
42119 if (PyErr_Occurred()) SWIG_fail;
42120 }
42121 {
42122 resultobj = wxPyMake_wxObject(result, (bool)0);
42123 }
42124 return resultobj;
42125 fail:
42126 return NULL;
42127 }
42128
42129
42130 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42131 PyObject *resultobj = 0;
42132 wxMenu *arg1 = (wxMenu *) 0 ;
42133 size_t arg2 ;
42134 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42135 wxMenuItem *result = 0 ;
42136 void *argp1 = 0 ;
42137 int res1 = 0 ;
42138 size_t val2 ;
42139 int ecode2 = 0 ;
42140 int res3 = 0 ;
42141 PyObject * obj0 = 0 ;
42142 PyObject * obj1 = 0 ;
42143 PyObject * obj2 = 0 ;
42144 char * kwnames[] = {
42145 (char *) "self",(char *) "pos",(char *) "item", NULL
42146 };
42147
42148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42150 if (!SWIG_IsOK(res1)) {
42151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42152 }
42153 arg1 = reinterpret_cast< wxMenu * >(argp1);
42154 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42155 if (!SWIG_IsOK(ecode2)) {
42156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42157 }
42158 arg2 = static_cast< size_t >(val2);
42159 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42160 if (!SWIG_IsOK(res3)) {
42161 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42162 }
42163 {
42164 PyThreadState* __tstate = wxPyBeginAllowThreads();
42165 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42166 wxPyEndAllowThreads(__tstate);
42167 if (PyErr_Occurred()) SWIG_fail;
42168 }
42169 {
42170 resultobj = wxPyMake_wxObject(result, (bool)0);
42171 }
42172 return resultobj;
42173 fail:
42174 return NULL;
42175 }
42176
42177
42178 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42179 PyObject *resultobj = 0;
42180 wxMenu *arg1 = (wxMenu *) 0 ;
42181 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42182 wxMenuItem *result = 0 ;
42183 void *argp1 = 0 ;
42184 int res1 = 0 ;
42185 int res2 = 0 ;
42186 PyObject * obj0 = 0 ;
42187 PyObject * obj1 = 0 ;
42188 char * kwnames[] = {
42189 (char *) "self",(char *) "item", NULL
42190 };
42191
42192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42194 if (!SWIG_IsOK(res1)) {
42195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42196 }
42197 arg1 = reinterpret_cast< wxMenu * >(argp1);
42198 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42199 if (!SWIG_IsOK(res2)) {
42200 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42201 }
42202 {
42203 PyThreadState* __tstate = wxPyBeginAllowThreads();
42204 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42205 wxPyEndAllowThreads(__tstate);
42206 if (PyErr_Occurred()) SWIG_fail;
42207 }
42208 {
42209 resultobj = wxPyMake_wxObject(result, (bool)0);
42210 }
42211 return resultobj;
42212 fail:
42213 return NULL;
42214 }
42215
42216
42217 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42218 PyObject *resultobj = 0;
42219 wxMenu *arg1 = (wxMenu *) 0 ;
42220 void *argp1 = 0 ;
42221 int res1 = 0 ;
42222 PyObject *swig_obj[1] ;
42223
42224 if (!args) SWIG_fail;
42225 swig_obj[0] = args;
42226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42227 if (!SWIG_IsOK(res1)) {
42228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42229 }
42230 arg1 = reinterpret_cast< wxMenu * >(argp1);
42231 {
42232 PyThreadState* __tstate = wxPyBeginAllowThreads();
42233 (arg1)->Break();
42234 wxPyEndAllowThreads(__tstate);
42235 if (PyErr_Occurred()) SWIG_fail;
42236 }
42237 resultobj = SWIG_Py_Void();
42238 return resultobj;
42239 fail:
42240 return NULL;
42241 }
42242
42243
42244 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42245 PyObject *resultobj = 0;
42246 wxMenu *arg1 = (wxMenu *) 0 ;
42247 size_t arg2 ;
42248 int arg3 ;
42249 wxString const &arg4_defvalue = wxPyEmptyString ;
42250 wxString *arg4 = (wxString *) &arg4_defvalue ;
42251 wxString const &arg5_defvalue = wxPyEmptyString ;
42252 wxString *arg5 = (wxString *) &arg5_defvalue ;
42253 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42254 wxMenuItem *result = 0 ;
42255 void *argp1 = 0 ;
42256 int res1 = 0 ;
42257 size_t val2 ;
42258 int ecode2 = 0 ;
42259 int val3 ;
42260 int ecode3 = 0 ;
42261 bool temp4 = false ;
42262 bool temp5 = false ;
42263 int val6 ;
42264 int ecode6 = 0 ;
42265 PyObject * obj0 = 0 ;
42266 PyObject * obj1 = 0 ;
42267 PyObject * obj2 = 0 ;
42268 PyObject * obj3 = 0 ;
42269 PyObject * obj4 = 0 ;
42270 PyObject * obj5 = 0 ;
42271 char * kwnames[] = {
42272 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42273 };
42274
42275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42277 if (!SWIG_IsOK(res1)) {
42278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42279 }
42280 arg1 = reinterpret_cast< wxMenu * >(argp1);
42281 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42282 if (!SWIG_IsOK(ecode2)) {
42283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42284 }
42285 arg2 = static_cast< size_t >(val2);
42286 ecode3 = SWIG_AsVal_int(obj2, &val3);
42287 if (!SWIG_IsOK(ecode3)) {
42288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42289 }
42290 arg3 = static_cast< int >(val3);
42291 if (obj3) {
42292 {
42293 arg4 = wxString_in_helper(obj3);
42294 if (arg4 == NULL) SWIG_fail;
42295 temp4 = true;
42296 }
42297 }
42298 if (obj4) {
42299 {
42300 arg5 = wxString_in_helper(obj4);
42301 if (arg5 == NULL) SWIG_fail;
42302 temp5 = true;
42303 }
42304 }
42305 if (obj5) {
42306 ecode6 = SWIG_AsVal_int(obj5, &val6);
42307 if (!SWIG_IsOK(ecode6)) {
42308 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42309 }
42310 arg6 = static_cast< wxItemKind >(val6);
42311 }
42312 {
42313 PyThreadState* __tstate = wxPyBeginAllowThreads();
42314 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42315 wxPyEndAllowThreads(__tstate);
42316 if (PyErr_Occurred()) SWIG_fail;
42317 }
42318 {
42319 resultobj = wxPyMake_wxObject(result, (bool)0);
42320 }
42321 {
42322 if (temp4)
42323 delete arg4;
42324 }
42325 {
42326 if (temp5)
42327 delete arg5;
42328 }
42329 return resultobj;
42330 fail:
42331 {
42332 if (temp4)
42333 delete arg4;
42334 }
42335 {
42336 if (temp5)
42337 delete arg5;
42338 }
42339 return NULL;
42340 }
42341
42342
42343 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42344 PyObject *resultobj = 0;
42345 wxMenu *arg1 = (wxMenu *) 0 ;
42346 size_t arg2 ;
42347 wxMenuItem *result = 0 ;
42348 void *argp1 = 0 ;
42349 int res1 = 0 ;
42350 size_t val2 ;
42351 int ecode2 = 0 ;
42352 PyObject * obj0 = 0 ;
42353 PyObject * obj1 = 0 ;
42354 char * kwnames[] = {
42355 (char *) "self",(char *) "pos", NULL
42356 };
42357
42358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42360 if (!SWIG_IsOK(res1)) {
42361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42362 }
42363 arg1 = reinterpret_cast< wxMenu * >(argp1);
42364 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42365 if (!SWIG_IsOK(ecode2)) {
42366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42367 }
42368 arg2 = static_cast< size_t >(val2);
42369 {
42370 PyThreadState* __tstate = wxPyBeginAllowThreads();
42371 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42372 wxPyEndAllowThreads(__tstate);
42373 if (PyErr_Occurred()) SWIG_fail;
42374 }
42375 {
42376 resultobj = wxPyMake_wxObject(result, (bool)0);
42377 }
42378 return resultobj;
42379 fail:
42380 return NULL;
42381 }
42382
42383
42384 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42385 PyObject *resultobj = 0;
42386 wxMenu *arg1 = (wxMenu *) 0 ;
42387 size_t arg2 ;
42388 int arg3 ;
42389 wxString *arg4 = 0 ;
42390 wxString const &arg5_defvalue = wxPyEmptyString ;
42391 wxString *arg5 = (wxString *) &arg5_defvalue ;
42392 wxMenuItem *result = 0 ;
42393 void *argp1 = 0 ;
42394 int res1 = 0 ;
42395 size_t val2 ;
42396 int ecode2 = 0 ;
42397 int val3 ;
42398 int ecode3 = 0 ;
42399 bool temp4 = false ;
42400 bool temp5 = false ;
42401 PyObject * obj0 = 0 ;
42402 PyObject * obj1 = 0 ;
42403 PyObject * obj2 = 0 ;
42404 PyObject * obj3 = 0 ;
42405 PyObject * obj4 = 0 ;
42406 char * kwnames[] = {
42407 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42408 };
42409
42410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42412 if (!SWIG_IsOK(res1)) {
42413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42414 }
42415 arg1 = reinterpret_cast< wxMenu * >(argp1);
42416 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42417 if (!SWIG_IsOK(ecode2)) {
42418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42419 }
42420 arg2 = static_cast< size_t >(val2);
42421 ecode3 = SWIG_AsVal_int(obj2, &val3);
42422 if (!SWIG_IsOK(ecode3)) {
42423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42424 }
42425 arg3 = static_cast< int >(val3);
42426 {
42427 arg4 = wxString_in_helper(obj3);
42428 if (arg4 == NULL) SWIG_fail;
42429 temp4 = true;
42430 }
42431 if (obj4) {
42432 {
42433 arg5 = wxString_in_helper(obj4);
42434 if (arg5 == NULL) SWIG_fail;
42435 temp5 = true;
42436 }
42437 }
42438 {
42439 PyThreadState* __tstate = wxPyBeginAllowThreads();
42440 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42441 wxPyEndAllowThreads(__tstate);
42442 if (PyErr_Occurred()) SWIG_fail;
42443 }
42444 {
42445 resultobj = wxPyMake_wxObject(result, (bool)0);
42446 }
42447 {
42448 if (temp4)
42449 delete arg4;
42450 }
42451 {
42452 if (temp5)
42453 delete arg5;
42454 }
42455 return resultobj;
42456 fail:
42457 {
42458 if (temp4)
42459 delete arg4;
42460 }
42461 {
42462 if (temp5)
42463 delete arg5;
42464 }
42465 return NULL;
42466 }
42467
42468
42469 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42470 PyObject *resultobj = 0;
42471 wxMenu *arg1 = (wxMenu *) 0 ;
42472 size_t arg2 ;
42473 int arg3 ;
42474 wxString *arg4 = 0 ;
42475 wxString const &arg5_defvalue = wxPyEmptyString ;
42476 wxString *arg5 = (wxString *) &arg5_defvalue ;
42477 wxMenuItem *result = 0 ;
42478 void *argp1 = 0 ;
42479 int res1 = 0 ;
42480 size_t val2 ;
42481 int ecode2 = 0 ;
42482 int val3 ;
42483 int ecode3 = 0 ;
42484 bool temp4 = false ;
42485 bool temp5 = false ;
42486 PyObject * obj0 = 0 ;
42487 PyObject * obj1 = 0 ;
42488 PyObject * obj2 = 0 ;
42489 PyObject * obj3 = 0 ;
42490 PyObject * obj4 = 0 ;
42491 char * kwnames[] = {
42492 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42493 };
42494
42495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42497 if (!SWIG_IsOK(res1)) {
42498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42499 }
42500 arg1 = reinterpret_cast< wxMenu * >(argp1);
42501 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42502 if (!SWIG_IsOK(ecode2)) {
42503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42504 }
42505 arg2 = static_cast< size_t >(val2);
42506 ecode3 = SWIG_AsVal_int(obj2, &val3);
42507 if (!SWIG_IsOK(ecode3)) {
42508 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42509 }
42510 arg3 = static_cast< int >(val3);
42511 {
42512 arg4 = wxString_in_helper(obj3);
42513 if (arg4 == NULL) SWIG_fail;
42514 temp4 = true;
42515 }
42516 if (obj4) {
42517 {
42518 arg5 = wxString_in_helper(obj4);
42519 if (arg5 == NULL) SWIG_fail;
42520 temp5 = true;
42521 }
42522 }
42523 {
42524 PyThreadState* __tstate = wxPyBeginAllowThreads();
42525 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42526 wxPyEndAllowThreads(__tstate);
42527 if (PyErr_Occurred()) SWIG_fail;
42528 }
42529 {
42530 resultobj = wxPyMake_wxObject(result, (bool)0);
42531 }
42532 {
42533 if (temp4)
42534 delete arg4;
42535 }
42536 {
42537 if (temp5)
42538 delete arg5;
42539 }
42540 return resultobj;
42541 fail:
42542 {
42543 if (temp4)
42544 delete arg4;
42545 }
42546 {
42547 if (temp5)
42548 delete arg5;
42549 }
42550 return NULL;
42551 }
42552
42553
42554 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42555 PyObject *resultobj = 0;
42556 wxMenu *arg1 = (wxMenu *) 0 ;
42557 size_t arg2 ;
42558 int arg3 ;
42559 wxString *arg4 = 0 ;
42560 wxMenu *arg5 = (wxMenu *) 0 ;
42561 wxString const &arg6_defvalue = wxPyEmptyString ;
42562 wxString *arg6 = (wxString *) &arg6_defvalue ;
42563 wxMenuItem *result = 0 ;
42564 void *argp1 = 0 ;
42565 int res1 = 0 ;
42566 size_t val2 ;
42567 int ecode2 = 0 ;
42568 int val3 ;
42569 int ecode3 = 0 ;
42570 bool temp4 = false ;
42571 void *argp5 = 0 ;
42572 int res5 = 0 ;
42573 bool temp6 = false ;
42574 PyObject * obj0 = 0 ;
42575 PyObject * obj1 = 0 ;
42576 PyObject * obj2 = 0 ;
42577 PyObject * obj3 = 0 ;
42578 PyObject * obj4 = 0 ;
42579 PyObject * obj5 = 0 ;
42580 char * kwnames[] = {
42581 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42582 };
42583
42584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42586 if (!SWIG_IsOK(res1)) {
42587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42588 }
42589 arg1 = reinterpret_cast< wxMenu * >(argp1);
42590 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42591 if (!SWIG_IsOK(ecode2)) {
42592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42593 }
42594 arg2 = static_cast< size_t >(val2);
42595 ecode3 = SWIG_AsVal_int(obj2, &val3);
42596 if (!SWIG_IsOK(ecode3)) {
42597 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42598 }
42599 arg3 = static_cast< int >(val3);
42600 {
42601 arg4 = wxString_in_helper(obj3);
42602 if (arg4 == NULL) SWIG_fail;
42603 temp4 = true;
42604 }
42605 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42606 if (!SWIG_IsOK(res5)) {
42607 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42608 }
42609 arg5 = reinterpret_cast< wxMenu * >(argp5);
42610 if (obj5) {
42611 {
42612 arg6 = wxString_in_helper(obj5);
42613 if (arg6 == NULL) SWIG_fail;
42614 temp6 = true;
42615 }
42616 }
42617 {
42618 PyThreadState* __tstate = wxPyBeginAllowThreads();
42619 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42620 wxPyEndAllowThreads(__tstate);
42621 if (PyErr_Occurred()) SWIG_fail;
42622 }
42623 {
42624 resultobj = wxPyMake_wxObject(result, (bool)0);
42625 }
42626 {
42627 if (temp4)
42628 delete arg4;
42629 }
42630 {
42631 if (temp6)
42632 delete arg6;
42633 }
42634 return resultobj;
42635 fail:
42636 {
42637 if (temp4)
42638 delete arg4;
42639 }
42640 {
42641 if (temp6)
42642 delete arg6;
42643 }
42644 return NULL;
42645 }
42646
42647
42648 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42649 PyObject *resultobj = 0;
42650 wxMenu *arg1 = (wxMenu *) 0 ;
42651 int arg2 ;
42652 wxString const &arg3_defvalue = wxPyEmptyString ;
42653 wxString *arg3 = (wxString *) &arg3_defvalue ;
42654 wxString const &arg4_defvalue = wxPyEmptyString ;
42655 wxString *arg4 = (wxString *) &arg4_defvalue ;
42656 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42657 wxMenuItem *result = 0 ;
42658 void *argp1 = 0 ;
42659 int res1 = 0 ;
42660 int val2 ;
42661 int ecode2 = 0 ;
42662 bool temp3 = false ;
42663 bool temp4 = false ;
42664 int val5 ;
42665 int ecode5 = 0 ;
42666 PyObject * obj0 = 0 ;
42667 PyObject * obj1 = 0 ;
42668 PyObject * obj2 = 0 ;
42669 PyObject * obj3 = 0 ;
42670 PyObject * obj4 = 0 ;
42671 char * kwnames[] = {
42672 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42673 };
42674
42675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42677 if (!SWIG_IsOK(res1)) {
42678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
42679 }
42680 arg1 = reinterpret_cast< wxMenu * >(argp1);
42681 ecode2 = SWIG_AsVal_int(obj1, &val2);
42682 if (!SWIG_IsOK(ecode2)) {
42683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
42684 }
42685 arg2 = static_cast< int >(val2);
42686 if (obj2) {
42687 {
42688 arg3 = wxString_in_helper(obj2);
42689 if (arg3 == NULL) SWIG_fail;
42690 temp3 = true;
42691 }
42692 }
42693 if (obj3) {
42694 {
42695 arg4 = wxString_in_helper(obj3);
42696 if (arg4 == NULL) SWIG_fail;
42697 temp4 = true;
42698 }
42699 }
42700 if (obj4) {
42701 ecode5 = SWIG_AsVal_int(obj4, &val5);
42702 if (!SWIG_IsOK(ecode5)) {
42703 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
42704 }
42705 arg5 = static_cast< wxItemKind >(val5);
42706 }
42707 {
42708 PyThreadState* __tstate = wxPyBeginAllowThreads();
42709 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42710 wxPyEndAllowThreads(__tstate);
42711 if (PyErr_Occurred()) SWIG_fail;
42712 }
42713 {
42714 resultobj = wxPyMake_wxObject(result, (bool)0);
42715 }
42716 {
42717 if (temp3)
42718 delete arg3;
42719 }
42720 {
42721 if (temp4)
42722 delete arg4;
42723 }
42724 return resultobj;
42725 fail:
42726 {
42727 if (temp3)
42728 delete arg3;
42729 }
42730 {
42731 if (temp4)
42732 delete arg4;
42733 }
42734 return NULL;
42735 }
42736
42737
42738 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42739 PyObject *resultobj = 0;
42740 wxMenu *arg1 = (wxMenu *) 0 ;
42741 wxMenuItem *result = 0 ;
42742 void *argp1 = 0 ;
42743 int res1 = 0 ;
42744 PyObject *swig_obj[1] ;
42745
42746 if (!args) SWIG_fail;
42747 swig_obj[0] = args;
42748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42749 if (!SWIG_IsOK(res1)) {
42750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42751 }
42752 arg1 = reinterpret_cast< wxMenu * >(argp1);
42753 {
42754 PyThreadState* __tstate = wxPyBeginAllowThreads();
42755 result = (wxMenuItem *)(arg1)->PrependSeparator();
42756 wxPyEndAllowThreads(__tstate);
42757 if (PyErr_Occurred()) SWIG_fail;
42758 }
42759 {
42760 resultobj = wxPyMake_wxObject(result, (bool)0);
42761 }
42762 return resultobj;
42763 fail:
42764 return NULL;
42765 }
42766
42767
42768 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42769 PyObject *resultobj = 0;
42770 wxMenu *arg1 = (wxMenu *) 0 ;
42771 int arg2 ;
42772 wxString *arg3 = 0 ;
42773 wxString const &arg4_defvalue = wxPyEmptyString ;
42774 wxString *arg4 = (wxString *) &arg4_defvalue ;
42775 wxMenuItem *result = 0 ;
42776 void *argp1 = 0 ;
42777 int res1 = 0 ;
42778 int val2 ;
42779 int ecode2 = 0 ;
42780 bool temp3 = false ;
42781 bool temp4 = false ;
42782 PyObject * obj0 = 0 ;
42783 PyObject * obj1 = 0 ;
42784 PyObject * obj2 = 0 ;
42785 PyObject * obj3 = 0 ;
42786 char * kwnames[] = {
42787 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42788 };
42789
42790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42792 if (!SWIG_IsOK(res1)) {
42793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42794 }
42795 arg1 = reinterpret_cast< wxMenu * >(argp1);
42796 ecode2 = SWIG_AsVal_int(obj1, &val2);
42797 if (!SWIG_IsOK(ecode2)) {
42798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
42799 }
42800 arg2 = static_cast< int >(val2);
42801 {
42802 arg3 = wxString_in_helper(obj2);
42803 if (arg3 == NULL) SWIG_fail;
42804 temp3 = true;
42805 }
42806 if (obj3) {
42807 {
42808 arg4 = wxString_in_helper(obj3);
42809 if (arg4 == NULL) SWIG_fail;
42810 temp4 = true;
42811 }
42812 }
42813 {
42814 PyThreadState* __tstate = wxPyBeginAllowThreads();
42815 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42816 wxPyEndAllowThreads(__tstate);
42817 if (PyErr_Occurred()) SWIG_fail;
42818 }
42819 {
42820 resultobj = wxPyMake_wxObject(result, (bool)0);
42821 }
42822 {
42823 if (temp3)
42824 delete arg3;
42825 }
42826 {
42827 if (temp4)
42828 delete arg4;
42829 }
42830 return resultobj;
42831 fail:
42832 {
42833 if (temp3)
42834 delete arg3;
42835 }
42836 {
42837 if (temp4)
42838 delete arg4;
42839 }
42840 return NULL;
42841 }
42842
42843
42844 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42845 PyObject *resultobj = 0;
42846 wxMenu *arg1 = (wxMenu *) 0 ;
42847 int arg2 ;
42848 wxString *arg3 = 0 ;
42849 wxString const &arg4_defvalue = wxPyEmptyString ;
42850 wxString *arg4 = (wxString *) &arg4_defvalue ;
42851 wxMenuItem *result = 0 ;
42852 void *argp1 = 0 ;
42853 int res1 = 0 ;
42854 int val2 ;
42855 int ecode2 = 0 ;
42856 bool temp3 = false ;
42857 bool temp4 = false ;
42858 PyObject * obj0 = 0 ;
42859 PyObject * obj1 = 0 ;
42860 PyObject * obj2 = 0 ;
42861 PyObject * obj3 = 0 ;
42862 char * kwnames[] = {
42863 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42864 };
42865
42866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42868 if (!SWIG_IsOK(res1)) {
42869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42870 }
42871 arg1 = reinterpret_cast< wxMenu * >(argp1);
42872 ecode2 = SWIG_AsVal_int(obj1, &val2);
42873 if (!SWIG_IsOK(ecode2)) {
42874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
42875 }
42876 arg2 = static_cast< int >(val2);
42877 {
42878 arg3 = wxString_in_helper(obj2);
42879 if (arg3 == NULL) SWIG_fail;
42880 temp3 = true;
42881 }
42882 if (obj3) {
42883 {
42884 arg4 = wxString_in_helper(obj3);
42885 if (arg4 == NULL) SWIG_fail;
42886 temp4 = true;
42887 }
42888 }
42889 {
42890 PyThreadState* __tstate = wxPyBeginAllowThreads();
42891 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42892 wxPyEndAllowThreads(__tstate);
42893 if (PyErr_Occurred()) SWIG_fail;
42894 }
42895 {
42896 resultobj = wxPyMake_wxObject(result, (bool)0);
42897 }
42898 {
42899 if (temp3)
42900 delete arg3;
42901 }
42902 {
42903 if (temp4)
42904 delete arg4;
42905 }
42906 return resultobj;
42907 fail:
42908 {
42909 if (temp3)
42910 delete arg3;
42911 }
42912 {
42913 if (temp4)
42914 delete arg4;
42915 }
42916 return NULL;
42917 }
42918
42919
42920 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42921 PyObject *resultobj = 0;
42922 wxMenu *arg1 = (wxMenu *) 0 ;
42923 int arg2 ;
42924 wxString *arg3 = 0 ;
42925 wxMenu *arg4 = (wxMenu *) 0 ;
42926 wxString const &arg5_defvalue = wxPyEmptyString ;
42927 wxString *arg5 = (wxString *) &arg5_defvalue ;
42928 wxMenuItem *result = 0 ;
42929 void *argp1 = 0 ;
42930 int res1 = 0 ;
42931 int val2 ;
42932 int ecode2 = 0 ;
42933 bool temp3 = false ;
42934 void *argp4 = 0 ;
42935 int res4 = 0 ;
42936 bool temp5 = false ;
42937 PyObject * obj0 = 0 ;
42938 PyObject * obj1 = 0 ;
42939 PyObject * obj2 = 0 ;
42940 PyObject * obj3 = 0 ;
42941 PyObject * obj4 = 0 ;
42942 char * kwnames[] = {
42943 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42944 };
42945
42946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42948 if (!SWIG_IsOK(res1)) {
42949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42950 }
42951 arg1 = reinterpret_cast< wxMenu * >(argp1);
42952 ecode2 = SWIG_AsVal_int(obj1, &val2);
42953 if (!SWIG_IsOK(ecode2)) {
42954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
42955 }
42956 arg2 = static_cast< int >(val2);
42957 {
42958 arg3 = wxString_in_helper(obj2);
42959 if (arg3 == NULL) SWIG_fail;
42960 temp3 = true;
42961 }
42962 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42963 if (!SWIG_IsOK(res4)) {
42964 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42965 }
42966 arg4 = reinterpret_cast< wxMenu * >(argp4);
42967 if (obj4) {
42968 {
42969 arg5 = wxString_in_helper(obj4);
42970 if (arg5 == NULL) SWIG_fail;
42971 temp5 = true;
42972 }
42973 }
42974 {
42975 PyThreadState* __tstate = wxPyBeginAllowThreads();
42976 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42977 wxPyEndAllowThreads(__tstate);
42978 if (PyErr_Occurred()) SWIG_fail;
42979 }
42980 {
42981 resultobj = wxPyMake_wxObject(result, (bool)0);
42982 }
42983 {
42984 if (temp3)
42985 delete arg3;
42986 }
42987 {
42988 if (temp5)
42989 delete arg5;
42990 }
42991 return resultobj;
42992 fail:
42993 {
42994 if (temp3)
42995 delete arg3;
42996 }
42997 {
42998 if (temp5)
42999 delete arg5;
43000 }
43001 return NULL;
43002 }
43003
43004
43005 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43006 PyObject *resultobj = 0;
43007 wxMenu *arg1 = (wxMenu *) 0 ;
43008 int arg2 ;
43009 wxMenuItem *result = 0 ;
43010 void *argp1 = 0 ;
43011 int res1 = 0 ;
43012 int val2 ;
43013 int ecode2 = 0 ;
43014 PyObject * obj0 = 0 ;
43015 PyObject * obj1 = 0 ;
43016 char * kwnames[] = {
43017 (char *) "self",(char *) "id", NULL
43018 };
43019
43020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43022 if (!SWIG_IsOK(res1)) {
43023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43024 }
43025 arg1 = reinterpret_cast< wxMenu * >(argp1);
43026 ecode2 = SWIG_AsVal_int(obj1, &val2);
43027 if (!SWIG_IsOK(ecode2)) {
43028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43029 }
43030 arg2 = static_cast< int >(val2);
43031 {
43032 PyThreadState* __tstate = wxPyBeginAllowThreads();
43033 result = (wxMenuItem *)(arg1)->Remove(arg2);
43034 wxPyEndAllowThreads(__tstate);
43035 if (PyErr_Occurred()) SWIG_fail;
43036 }
43037 {
43038 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43039 }
43040 return resultobj;
43041 fail:
43042 return NULL;
43043 }
43044
43045
43046 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43047 PyObject *resultobj = 0;
43048 wxMenu *arg1 = (wxMenu *) 0 ;
43049 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43050 wxMenuItem *result = 0 ;
43051 void *argp1 = 0 ;
43052 int res1 = 0 ;
43053 void *argp2 = 0 ;
43054 int res2 = 0 ;
43055 PyObject * obj0 = 0 ;
43056 PyObject * obj1 = 0 ;
43057 char * kwnames[] = {
43058 (char *) "self",(char *) "item", NULL
43059 };
43060
43061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43063 if (!SWIG_IsOK(res1)) {
43064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43065 }
43066 arg1 = reinterpret_cast< wxMenu * >(argp1);
43067 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43068 if (!SWIG_IsOK(res2)) {
43069 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43070 }
43071 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43072 {
43073 PyThreadState* __tstate = wxPyBeginAllowThreads();
43074 result = (wxMenuItem *)(arg1)->Remove(arg2);
43075 wxPyEndAllowThreads(__tstate);
43076 if (PyErr_Occurred()) SWIG_fail;
43077 }
43078 {
43079 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43080 }
43081 return resultobj;
43082 fail:
43083 return NULL;
43084 }
43085
43086
43087 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43088 PyObject *resultobj = 0;
43089 wxMenu *arg1 = (wxMenu *) 0 ;
43090 int arg2 ;
43091 bool result;
43092 void *argp1 = 0 ;
43093 int res1 = 0 ;
43094 int val2 ;
43095 int ecode2 = 0 ;
43096 PyObject * obj0 = 0 ;
43097 PyObject * obj1 = 0 ;
43098 char * kwnames[] = {
43099 (char *) "self",(char *) "id", NULL
43100 };
43101
43102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43104 if (!SWIG_IsOK(res1)) {
43105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43106 }
43107 arg1 = reinterpret_cast< wxMenu * >(argp1);
43108 ecode2 = SWIG_AsVal_int(obj1, &val2);
43109 if (!SWIG_IsOK(ecode2)) {
43110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43111 }
43112 arg2 = static_cast< int >(val2);
43113 {
43114 PyThreadState* __tstate = wxPyBeginAllowThreads();
43115 result = (bool)(arg1)->Delete(arg2);
43116 wxPyEndAllowThreads(__tstate);
43117 if (PyErr_Occurred()) SWIG_fail;
43118 }
43119 {
43120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43121 }
43122 return resultobj;
43123 fail:
43124 return NULL;
43125 }
43126
43127
43128 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43129 PyObject *resultobj = 0;
43130 wxMenu *arg1 = (wxMenu *) 0 ;
43131 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43132 bool result;
43133 void *argp1 = 0 ;
43134 int res1 = 0 ;
43135 void *argp2 = 0 ;
43136 int res2 = 0 ;
43137 PyObject * obj0 = 0 ;
43138 PyObject * obj1 = 0 ;
43139 char * kwnames[] = {
43140 (char *) "self",(char *) "item", NULL
43141 };
43142
43143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43145 if (!SWIG_IsOK(res1)) {
43146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43147 }
43148 arg1 = reinterpret_cast< wxMenu * >(argp1);
43149 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43150 if (!SWIG_IsOK(res2)) {
43151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43152 }
43153 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43154 {
43155 PyThreadState* __tstate = wxPyBeginAllowThreads();
43156 result = (bool)(arg1)->Delete(arg2);
43157 wxPyEndAllowThreads(__tstate);
43158 if (PyErr_Occurred()) SWIG_fail;
43159 }
43160 {
43161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43162 }
43163 return resultobj;
43164 fail:
43165 return NULL;
43166 }
43167
43168
43169 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43170 PyObject *resultobj = 0;
43171 wxMenu *arg1 = (wxMenu *) 0 ;
43172 void *argp1 = 0 ;
43173 int res1 = 0 ;
43174 PyObject *swig_obj[1] ;
43175
43176 if (!args) SWIG_fail;
43177 swig_obj[0] = args;
43178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43179 if (!SWIG_IsOK(res1)) {
43180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43181 }
43182 arg1 = reinterpret_cast< wxMenu * >(argp1);
43183 {
43184 PyThreadState* __tstate = wxPyBeginAllowThreads();
43185 wxMenu_Destroy(arg1);
43186 wxPyEndAllowThreads(__tstate);
43187 if (PyErr_Occurred()) SWIG_fail;
43188 }
43189 resultobj = SWIG_Py_Void();
43190 return resultobj;
43191 fail:
43192 return NULL;
43193 }
43194
43195
43196 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43197 PyObject *resultobj = 0;
43198 wxMenu *arg1 = (wxMenu *) 0 ;
43199 int arg2 ;
43200 bool result;
43201 void *argp1 = 0 ;
43202 int res1 = 0 ;
43203 int val2 ;
43204 int ecode2 = 0 ;
43205 PyObject * obj0 = 0 ;
43206 PyObject * obj1 = 0 ;
43207 char * kwnames[] = {
43208 (char *) "self",(char *) "id", NULL
43209 };
43210
43211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43213 if (!SWIG_IsOK(res1)) {
43214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43215 }
43216 arg1 = reinterpret_cast< wxMenu * >(argp1);
43217 ecode2 = SWIG_AsVal_int(obj1, &val2);
43218 if (!SWIG_IsOK(ecode2)) {
43219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43220 }
43221 arg2 = static_cast< int >(val2);
43222 {
43223 PyThreadState* __tstate = wxPyBeginAllowThreads();
43224 result = (bool)(arg1)->Destroy(arg2);
43225 wxPyEndAllowThreads(__tstate);
43226 if (PyErr_Occurred()) SWIG_fail;
43227 }
43228 {
43229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43230 }
43231 return resultobj;
43232 fail:
43233 return NULL;
43234 }
43235
43236
43237 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43238 PyObject *resultobj = 0;
43239 wxMenu *arg1 = (wxMenu *) 0 ;
43240 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43241 bool result;
43242 void *argp1 = 0 ;
43243 int res1 = 0 ;
43244 void *argp2 = 0 ;
43245 int res2 = 0 ;
43246 PyObject * obj0 = 0 ;
43247 PyObject * obj1 = 0 ;
43248 char * kwnames[] = {
43249 (char *) "self",(char *) "item", NULL
43250 };
43251
43252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43254 if (!SWIG_IsOK(res1)) {
43255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43256 }
43257 arg1 = reinterpret_cast< wxMenu * >(argp1);
43258 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43259 if (!SWIG_IsOK(res2)) {
43260 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43261 }
43262 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43263 {
43264 PyThreadState* __tstate = wxPyBeginAllowThreads();
43265 result = (bool)(arg1)->Destroy(arg2);
43266 wxPyEndAllowThreads(__tstate);
43267 if (PyErr_Occurred()) SWIG_fail;
43268 }
43269 {
43270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43271 }
43272 return resultobj;
43273 fail:
43274 return NULL;
43275 }
43276
43277
43278 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43279 PyObject *resultobj = 0;
43280 wxMenu *arg1 = (wxMenu *) 0 ;
43281 size_t result;
43282 void *argp1 = 0 ;
43283 int res1 = 0 ;
43284 PyObject *swig_obj[1] ;
43285
43286 if (!args) SWIG_fail;
43287 swig_obj[0] = args;
43288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43289 if (!SWIG_IsOK(res1)) {
43290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43291 }
43292 arg1 = reinterpret_cast< wxMenu * >(argp1);
43293 {
43294 PyThreadState* __tstate = wxPyBeginAllowThreads();
43295 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43296 wxPyEndAllowThreads(__tstate);
43297 if (PyErr_Occurred()) SWIG_fail;
43298 }
43299 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43300 return resultobj;
43301 fail:
43302 return NULL;
43303 }
43304
43305
43306 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43307 PyObject *resultobj = 0;
43308 wxMenu *arg1 = (wxMenu *) 0 ;
43309 PyObject *result = 0 ;
43310 void *argp1 = 0 ;
43311 int res1 = 0 ;
43312 PyObject *swig_obj[1] ;
43313
43314 if (!args) SWIG_fail;
43315 swig_obj[0] = args;
43316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43317 if (!SWIG_IsOK(res1)) {
43318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43319 }
43320 arg1 = reinterpret_cast< wxMenu * >(argp1);
43321 {
43322 PyThreadState* __tstate = wxPyBeginAllowThreads();
43323 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43324 wxPyEndAllowThreads(__tstate);
43325 if (PyErr_Occurred()) SWIG_fail;
43326 }
43327 resultobj = result;
43328 return resultobj;
43329 fail:
43330 return NULL;
43331 }
43332
43333
43334 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43335 PyObject *resultobj = 0;
43336 wxMenu *arg1 = (wxMenu *) 0 ;
43337 wxString *arg2 = 0 ;
43338 int result;
43339 void *argp1 = 0 ;
43340 int res1 = 0 ;
43341 bool temp2 = false ;
43342 PyObject * obj0 = 0 ;
43343 PyObject * obj1 = 0 ;
43344 char * kwnames[] = {
43345 (char *) "self",(char *) "item", NULL
43346 };
43347
43348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43350 if (!SWIG_IsOK(res1)) {
43351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43352 }
43353 arg1 = reinterpret_cast< wxMenu * >(argp1);
43354 {
43355 arg2 = wxString_in_helper(obj1);
43356 if (arg2 == NULL) SWIG_fail;
43357 temp2 = true;
43358 }
43359 {
43360 PyThreadState* __tstate = wxPyBeginAllowThreads();
43361 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43362 wxPyEndAllowThreads(__tstate);
43363 if (PyErr_Occurred()) SWIG_fail;
43364 }
43365 resultobj = SWIG_From_int(static_cast< int >(result));
43366 {
43367 if (temp2)
43368 delete arg2;
43369 }
43370 return resultobj;
43371 fail:
43372 {
43373 if (temp2)
43374 delete arg2;
43375 }
43376 return NULL;
43377 }
43378
43379
43380 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43381 PyObject *resultobj = 0;
43382 wxMenu *arg1 = (wxMenu *) 0 ;
43383 int arg2 ;
43384 wxMenuItem *result = 0 ;
43385 void *argp1 = 0 ;
43386 int res1 = 0 ;
43387 int val2 ;
43388 int ecode2 = 0 ;
43389 PyObject * obj0 = 0 ;
43390 PyObject * obj1 = 0 ;
43391 char * kwnames[] = {
43392 (char *) "self",(char *) "id", NULL
43393 };
43394
43395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43397 if (!SWIG_IsOK(res1)) {
43398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43399 }
43400 arg1 = reinterpret_cast< wxMenu * >(argp1);
43401 ecode2 = SWIG_AsVal_int(obj1, &val2);
43402 if (!SWIG_IsOK(ecode2)) {
43403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43404 }
43405 arg2 = static_cast< int >(val2);
43406 {
43407 PyThreadState* __tstate = wxPyBeginAllowThreads();
43408 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43409 wxPyEndAllowThreads(__tstate);
43410 if (PyErr_Occurred()) SWIG_fail;
43411 }
43412 {
43413 resultobj = wxPyMake_wxObject(result, (bool)0);
43414 }
43415 return resultobj;
43416 fail:
43417 return NULL;
43418 }
43419
43420
43421 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43422 PyObject *resultobj = 0;
43423 wxMenu *arg1 = (wxMenu *) 0 ;
43424 size_t arg2 ;
43425 wxMenuItem *result = 0 ;
43426 void *argp1 = 0 ;
43427 int res1 = 0 ;
43428 size_t val2 ;
43429 int ecode2 = 0 ;
43430 PyObject * obj0 = 0 ;
43431 PyObject * obj1 = 0 ;
43432 char * kwnames[] = {
43433 (char *) "self",(char *) "position", NULL
43434 };
43435
43436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43438 if (!SWIG_IsOK(res1)) {
43439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43440 }
43441 arg1 = reinterpret_cast< wxMenu * >(argp1);
43442 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43443 if (!SWIG_IsOK(ecode2)) {
43444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43445 }
43446 arg2 = static_cast< size_t >(val2);
43447 {
43448 PyThreadState* __tstate = wxPyBeginAllowThreads();
43449 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43450 wxPyEndAllowThreads(__tstate);
43451 if (PyErr_Occurred()) SWIG_fail;
43452 }
43453 {
43454 resultobj = wxPyMake_wxObject(result, (bool)0);
43455 }
43456 return resultobj;
43457 fail:
43458 return NULL;
43459 }
43460
43461
43462 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43463 PyObject *resultobj = 0;
43464 wxMenu *arg1 = (wxMenu *) 0 ;
43465 int arg2 ;
43466 bool arg3 ;
43467 void *argp1 = 0 ;
43468 int res1 = 0 ;
43469 int val2 ;
43470 int ecode2 = 0 ;
43471 bool val3 ;
43472 int ecode3 = 0 ;
43473 PyObject * obj0 = 0 ;
43474 PyObject * obj1 = 0 ;
43475 PyObject * obj2 = 0 ;
43476 char * kwnames[] = {
43477 (char *) "self",(char *) "id",(char *) "enable", NULL
43478 };
43479
43480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43482 if (!SWIG_IsOK(res1)) {
43483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43484 }
43485 arg1 = reinterpret_cast< wxMenu * >(argp1);
43486 ecode2 = SWIG_AsVal_int(obj1, &val2);
43487 if (!SWIG_IsOK(ecode2)) {
43488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43489 }
43490 arg2 = static_cast< int >(val2);
43491 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43492 if (!SWIG_IsOK(ecode3)) {
43493 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43494 }
43495 arg3 = static_cast< bool >(val3);
43496 {
43497 PyThreadState* __tstate = wxPyBeginAllowThreads();
43498 (arg1)->Enable(arg2,arg3);
43499 wxPyEndAllowThreads(__tstate);
43500 if (PyErr_Occurred()) SWIG_fail;
43501 }
43502 resultobj = SWIG_Py_Void();
43503 return resultobj;
43504 fail:
43505 return NULL;
43506 }
43507
43508
43509 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43510 PyObject *resultobj = 0;
43511 wxMenu *arg1 = (wxMenu *) 0 ;
43512 int arg2 ;
43513 bool result;
43514 void *argp1 = 0 ;
43515 int res1 = 0 ;
43516 int val2 ;
43517 int ecode2 = 0 ;
43518 PyObject * obj0 = 0 ;
43519 PyObject * obj1 = 0 ;
43520 char * kwnames[] = {
43521 (char *) "self",(char *) "id", NULL
43522 };
43523
43524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43526 if (!SWIG_IsOK(res1)) {
43527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43528 }
43529 arg1 = reinterpret_cast< wxMenu * >(argp1);
43530 ecode2 = SWIG_AsVal_int(obj1, &val2);
43531 if (!SWIG_IsOK(ecode2)) {
43532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43533 }
43534 arg2 = static_cast< int >(val2);
43535 {
43536 PyThreadState* __tstate = wxPyBeginAllowThreads();
43537 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43538 wxPyEndAllowThreads(__tstate);
43539 if (PyErr_Occurred()) SWIG_fail;
43540 }
43541 {
43542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43543 }
43544 return resultobj;
43545 fail:
43546 return NULL;
43547 }
43548
43549
43550 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43551 PyObject *resultobj = 0;
43552 wxMenu *arg1 = (wxMenu *) 0 ;
43553 int arg2 ;
43554 bool arg3 ;
43555 void *argp1 = 0 ;
43556 int res1 = 0 ;
43557 int val2 ;
43558 int ecode2 = 0 ;
43559 bool val3 ;
43560 int ecode3 = 0 ;
43561 PyObject * obj0 = 0 ;
43562 PyObject * obj1 = 0 ;
43563 PyObject * obj2 = 0 ;
43564 char * kwnames[] = {
43565 (char *) "self",(char *) "id",(char *) "check", NULL
43566 };
43567
43568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43570 if (!SWIG_IsOK(res1)) {
43571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43572 }
43573 arg1 = reinterpret_cast< wxMenu * >(argp1);
43574 ecode2 = SWIG_AsVal_int(obj1, &val2);
43575 if (!SWIG_IsOK(ecode2)) {
43576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43577 }
43578 arg2 = static_cast< int >(val2);
43579 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43580 if (!SWIG_IsOK(ecode3)) {
43581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43582 }
43583 arg3 = static_cast< bool >(val3);
43584 {
43585 PyThreadState* __tstate = wxPyBeginAllowThreads();
43586 (arg1)->Check(arg2,arg3);
43587 wxPyEndAllowThreads(__tstate);
43588 if (PyErr_Occurred()) SWIG_fail;
43589 }
43590 resultobj = SWIG_Py_Void();
43591 return resultobj;
43592 fail:
43593 return NULL;
43594 }
43595
43596
43597 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43598 PyObject *resultobj = 0;
43599 wxMenu *arg1 = (wxMenu *) 0 ;
43600 int arg2 ;
43601 bool result;
43602 void *argp1 = 0 ;
43603 int res1 = 0 ;
43604 int val2 ;
43605 int ecode2 = 0 ;
43606 PyObject * obj0 = 0 ;
43607 PyObject * obj1 = 0 ;
43608 char * kwnames[] = {
43609 (char *) "self",(char *) "id", NULL
43610 };
43611
43612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43614 if (!SWIG_IsOK(res1)) {
43615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43616 }
43617 arg1 = reinterpret_cast< wxMenu * >(argp1);
43618 ecode2 = SWIG_AsVal_int(obj1, &val2);
43619 if (!SWIG_IsOK(ecode2)) {
43620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43621 }
43622 arg2 = static_cast< int >(val2);
43623 {
43624 PyThreadState* __tstate = wxPyBeginAllowThreads();
43625 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43626 wxPyEndAllowThreads(__tstate);
43627 if (PyErr_Occurred()) SWIG_fail;
43628 }
43629 {
43630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43631 }
43632 return resultobj;
43633 fail:
43634 return NULL;
43635 }
43636
43637
43638 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43639 PyObject *resultobj = 0;
43640 wxMenu *arg1 = (wxMenu *) 0 ;
43641 int arg2 ;
43642 wxString *arg3 = 0 ;
43643 void *argp1 = 0 ;
43644 int res1 = 0 ;
43645 int val2 ;
43646 int ecode2 = 0 ;
43647 bool temp3 = false ;
43648 PyObject * obj0 = 0 ;
43649 PyObject * obj1 = 0 ;
43650 PyObject * obj2 = 0 ;
43651 char * kwnames[] = {
43652 (char *) "self",(char *) "id",(char *) "label", NULL
43653 };
43654
43655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43657 if (!SWIG_IsOK(res1)) {
43658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
43659 }
43660 arg1 = reinterpret_cast< wxMenu * >(argp1);
43661 ecode2 = SWIG_AsVal_int(obj1, &val2);
43662 if (!SWIG_IsOK(ecode2)) {
43663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
43664 }
43665 arg2 = static_cast< int >(val2);
43666 {
43667 arg3 = wxString_in_helper(obj2);
43668 if (arg3 == NULL) SWIG_fail;
43669 temp3 = true;
43670 }
43671 {
43672 PyThreadState* __tstate = wxPyBeginAllowThreads();
43673 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43674 wxPyEndAllowThreads(__tstate);
43675 if (PyErr_Occurred()) SWIG_fail;
43676 }
43677 resultobj = SWIG_Py_Void();
43678 {
43679 if (temp3)
43680 delete arg3;
43681 }
43682 return resultobj;
43683 fail:
43684 {
43685 if (temp3)
43686 delete arg3;
43687 }
43688 return NULL;
43689 }
43690
43691
43692 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43693 PyObject *resultobj = 0;
43694 wxMenu *arg1 = (wxMenu *) 0 ;
43695 int arg2 ;
43696 wxString result;
43697 void *argp1 = 0 ;
43698 int res1 = 0 ;
43699 int val2 ;
43700 int ecode2 = 0 ;
43701 PyObject * obj0 = 0 ;
43702 PyObject * obj1 = 0 ;
43703 char * kwnames[] = {
43704 (char *) "self",(char *) "id", NULL
43705 };
43706
43707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43709 if (!SWIG_IsOK(res1)) {
43710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
43711 }
43712 arg1 = reinterpret_cast< wxMenu * >(argp1);
43713 ecode2 = SWIG_AsVal_int(obj1, &val2);
43714 if (!SWIG_IsOK(ecode2)) {
43715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
43716 }
43717 arg2 = static_cast< int >(val2);
43718 {
43719 PyThreadState* __tstate = wxPyBeginAllowThreads();
43720 result = ((wxMenu const *)arg1)->GetLabel(arg2);
43721 wxPyEndAllowThreads(__tstate);
43722 if (PyErr_Occurred()) SWIG_fail;
43723 }
43724 {
43725 #if wxUSE_UNICODE
43726 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43727 #else
43728 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43729 #endif
43730 }
43731 return resultobj;
43732 fail:
43733 return NULL;
43734 }
43735
43736
43737 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43738 PyObject *resultobj = 0;
43739 wxMenu *arg1 = (wxMenu *) 0 ;
43740 int arg2 ;
43741 wxString *arg3 = 0 ;
43742 void *argp1 = 0 ;
43743 int res1 = 0 ;
43744 int val2 ;
43745 int ecode2 = 0 ;
43746 bool temp3 = false ;
43747 PyObject * obj0 = 0 ;
43748 PyObject * obj1 = 0 ;
43749 PyObject * obj2 = 0 ;
43750 char * kwnames[] = {
43751 (char *) "self",(char *) "id",(char *) "helpString", NULL
43752 };
43753
43754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43756 if (!SWIG_IsOK(res1)) {
43757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
43758 }
43759 arg1 = reinterpret_cast< wxMenu * >(argp1);
43760 ecode2 = SWIG_AsVal_int(obj1, &val2);
43761 if (!SWIG_IsOK(ecode2)) {
43762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43763 }
43764 arg2 = static_cast< int >(val2);
43765 {
43766 arg3 = wxString_in_helper(obj2);
43767 if (arg3 == NULL) SWIG_fail;
43768 temp3 = true;
43769 }
43770 {
43771 PyThreadState* __tstate = wxPyBeginAllowThreads();
43772 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43773 wxPyEndAllowThreads(__tstate);
43774 if (PyErr_Occurred()) SWIG_fail;
43775 }
43776 resultobj = SWIG_Py_Void();
43777 {
43778 if (temp3)
43779 delete arg3;
43780 }
43781 return resultobj;
43782 fail:
43783 {
43784 if (temp3)
43785 delete arg3;
43786 }
43787 return NULL;
43788 }
43789
43790
43791 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43792 PyObject *resultobj = 0;
43793 wxMenu *arg1 = (wxMenu *) 0 ;
43794 int arg2 ;
43795 wxString result;
43796 void *argp1 = 0 ;
43797 int res1 = 0 ;
43798 int val2 ;
43799 int ecode2 = 0 ;
43800 PyObject * obj0 = 0 ;
43801 PyObject * obj1 = 0 ;
43802 char * kwnames[] = {
43803 (char *) "self",(char *) "id", NULL
43804 };
43805
43806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43808 if (!SWIG_IsOK(res1)) {
43809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
43810 }
43811 arg1 = reinterpret_cast< wxMenu * >(argp1);
43812 ecode2 = SWIG_AsVal_int(obj1, &val2);
43813 if (!SWIG_IsOK(ecode2)) {
43814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43815 }
43816 arg2 = static_cast< int >(val2);
43817 {
43818 PyThreadState* __tstate = wxPyBeginAllowThreads();
43819 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
43820 wxPyEndAllowThreads(__tstate);
43821 if (PyErr_Occurred()) SWIG_fail;
43822 }
43823 {
43824 #if wxUSE_UNICODE
43825 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43826 #else
43827 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43828 #endif
43829 }
43830 return resultobj;
43831 fail:
43832 return NULL;
43833 }
43834
43835
43836 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43837 PyObject *resultobj = 0;
43838 wxMenu *arg1 = (wxMenu *) 0 ;
43839 wxString *arg2 = 0 ;
43840 void *argp1 = 0 ;
43841 int res1 = 0 ;
43842 bool temp2 = false ;
43843 PyObject * obj0 = 0 ;
43844 PyObject * obj1 = 0 ;
43845 char * kwnames[] = {
43846 (char *) "self",(char *) "title", NULL
43847 };
43848
43849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
43850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43851 if (!SWIG_IsOK(res1)) {
43852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
43853 }
43854 arg1 = reinterpret_cast< wxMenu * >(argp1);
43855 {
43856 arg2 = wxString_in_helper(obj1);
43857 if (arg2 == NULL) SWIG_fail;
43858 temp2 = true;
43859 }
43860 {
43861 PyThreadState* __tstate = wxPyBeginAllowThreads();
43862 (arg1)->SetTitle((wxString const &)*arg2);
43863 wxPyEndAllowThreads(__tstate);
43864 if (PyErr_Occurred()) SWIG_fail;
43865 }
43866 resultobj = SWIG_Py_Void();
43867 {
43868 if (temp2)
43869 delete arg2;
43870 }
43871 return resultobj;
43872 fail:
43873 {
43874 if (temp2)
43875 delete arg2;
43876 }
43877 return NULL;
43878 }
43879
43880
43881 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43882 PyObject *resultobj = 0;
43883 wxMenu *arg1 = (wxMenu *) 0 ;
43884 wxString result;
43885 void *argp1 = 0 ;
43886 int res1 = 0 ;
43887 PyObject *swig_obj[1] ;
43888
43889 if (!args) SWIG_fail;
43890 swig_obj[0] = args;
43891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43892 if (!SWIG_IsOK(res1)) {
43893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
43894 }
43895 arg1 = reinterpret_cast< wxMenu * >(argp1);
43896 {
43897 PyThreadState* __tstate = wxPyBeginAllowThreads();
43898 result = ((wxMenu const *)arg1)->GetTitle();
43899 wxPyEndAllowThreads(__tstate);
43900 if (PyErr_Occurred()) SWIG_fail;
43901 }
43902 {
43903 #if wxUSE_UNICODE
43904 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43905 #else
43906 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43907 #endif
43908 }
43909 return resultobj;
43910 fail:
43911 return NULL;
43912 }
43913
43914
43915 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43916 PyObject *resultobj = 0;
43917 wxMenu *arg1 = (wxMenu *) 0 ;
43918 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
43919 void *argp1 = 0 ;
43920 int res1 = 0 ;
43921 void *argp2 = 0 ;
43922 int res2 = 0 ;
43923 PyObject * obj0 = 0 ;
43924 PyObject * obj1 = 0 ;
43925 char * kwnames[] = {
43926 (char *) "self",(char *) "handler", NULL
43927 };
43928
43929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
43930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43931 if (!SWIG_IsOK(res1)) {
43932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
43933 }
43934 arg1 = reinterpret_cast< wxMenu * >(argp1);
43935 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
43936 if (!SWIG_IsOK(res2)) {
43937 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
43938 }
43939 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
43940 {
43941 PyThreadState* __tstate = wxPyBeginAllowThreads();
43942 (arg1)->SetEventHandler(arg2);
43943 wxPyEndAllowThreads(__tstate);
43944 if (PyErr_Occurred()) SWIG_fail;
43945 }
43946 resultobj = SWIG_Py_Void();
43947 return resultobj;
43948 fail:
43949 return NULL;
43950 }
43951
43952
43953 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43954 PyObject *resultobj = 0;
43955 wxMenu *arg1 = (wxMenu *) 0 ;
43956 wxEvtHandler *result = 0 ;
43957 void *argp1 = 0 ;
43958 int res1 = 0 ;
43959 PyObject *swig_obj[1] ;
43960
43961 if (!args) SWIG_fail;
43962 swig_obj[0] = args;
43963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43964 if (!SWIG_IsOK(res1)) {
43965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
43966 }
43967 arg1 = reinterpret_cast< wxMenu * >(argp1);
43968 {
43969 PyThreadState* __tstate = wxPyBeginAllowThreads();
43970 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
43971 wxPyEndAllowThreads(__tstate);
43972 if (PyErr_Occurred()) SWIG_fail;
43973 }
43974 {
43975 resultobj = wxPyMake_wxObject(result, 0);
43976 }
43977 return resultobj;
43978 fail:
43979 return NULL;
43980 }
43981
43982
43983 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43984 PyObject *resultobj = 0;
43985 wxMenu *arg1 = (wxMenu *) 0 ;
43986 wxWindow *arg2 = (wxWindow *) 0 ;
43987 void *argp1 = 0 ;
43988 int res1 = 0 ;
43989 void *argp2 = 0 ;
43990 int res2 = 0 ;
43991 PyObject * obj0 = 0 ;
43992 PyObject * obj1 = 0 ;
43993 char * kwnames[] = {
43994 (char *) "self",(char *) "win", NULL
43995 };
43996
43997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
43998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43999 if (!SWIG_IsOK(res1)) {
44000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44001 }
44002 arg1 = reinterpret_cast< wxMenu * >(argp1);
44003 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44004 if (!SWIG_IsOK(res2)) {
44005 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44006 }
44007 arg2 = reinterpret_cast< wxWindow * >(argp2);
44008 {
44009 PyThreadState* __tstate = wxPyBeginAllowThreads();
44010 (arg1)->SetInvokingWindow(arg2);
44011 wxPyEndAllowThreads(__tstate);
44012 if (PyErr_Occurred()) SWIG_fail;
44013 }
44014 resultobj = SWIG_Py_Void();
44015 return resultobj;
44016 fail:
44017 return NULL;
44018 }
44019
44020
44021 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44022 PyObject *resultobj = 0;
44023 wxMenu *arg1 = (wxMenu *) 0 ;
44024 wxWindow *result = 0 ;
44025 void *argp1 = 0 ;
44026 int res1 = 0 ;
44027 PyObject *swig_obj[1] ;
44028
44029 if (!args) SWIG_fail;
44030 swig_obj[0] = args;
44031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44032 if (!SWIG_IsOK(res1)) {
44033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44034 }
44035 arg1 = reinterpret_cast< wxMenu * >(argp1);
44036 {
44037 PyThreadState* __tstate = wxPyBeginAllowThreads();
44038 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44039 wxPyEndAllowThreads(__tstate);
44040 if (PyErr_Occurred()) SWIG_fail;
44041 }
44042 {
44043 resultobj = wxPyMake_wxObject(result, 0);
44044 }
44045 return resultobj;
44046 fail:
44047 return NULL;
44048 }
44049
44050
44051 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44052 PyObject *resultobj = 0;
44053 wxMenu *arg1 = (wxMenu *) 0 ;
44054 long result;
44055 void *argp1 = 0 ;
44056 int res1 = 0 ;
44057 PyObject *swig_obj[1] ;
44058
44059 if (!args) SWIG_fail;
44060 swig_obj[0] = args;
44061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44062 if (!SWIG_IsOK(res1)) {
44063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44064 }
44065 arg1 = reinterpret_cast< wxMenu * >(argp1);
44066 {
44067 PyThreadState* __tstate = wxPyBeginAllowThreads();
44068 result = (long)((wxMenu const *)arg1)->GetStyle();
44069 wxPyEndAllowThreads(__tstate);
44070 if (PyErr_Occurred()) SWIG_fail;
44071 }
44072 resultobj = SWIG_From_long(static_cast< long >(result));
44073 return resultobj;
44074 fail:
44075 return NULL;
44076 }
44077
44078
44079 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44080 PyObject *resultobj = 0;
44081 wxMenu *arg1 = (wxMenu *) 0 ;
44082 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44083 void *argp1 = 0 ;
44084 int res1 = 0 ;
44085 void *argp2 = 0 ;
44086 int res2 = 0 ;
44087 PyObject * obj0 = 0 ;
44088 PyObject * obj1 = 0 ;
44089 char * kwnames[] = {
44090 (char *) "self",(char *) "source", NULL
44091 };
44092
44093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44095 if (!SWIG_IsOK(res1)) {
44096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44097 }
44098 arg1 = reinterpret_cast< wxMenu * >(argp1);
44099 if (obj1) {
44100 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44101 if (!SWIG_IsOK(res2)) {
44102 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44103 }
44104 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44105 }
44106 {
44107 PyThreadState* __tstate = wxPyBeginAllowThreads();
44108 (arg1)->UpdateUI(arg2);
44109 wxPyEndAllowThreads(__tstate);
44110 if (PyErr_Occurred()) SWIG_fail;
44111 }
44112 resultobj = SWIG_Py_Void();
44113 return resultobj;
44114 fail:
44115 return NULL;
44116 }
44117
44118
44119 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44120 PyObject *resultobj = 0;
44121 wxMenu *arg1 = (wxMenu *) 0 ;
44122 wxMenuBar *result = 0 ;
44123 void *argp1 = 0 ;
44124 int res1 = 0 ;
44125 PyObject *swig_obj[1] ;
44126
44127 if (!args) SWIG_fail;
44128 swig_obj[0] = args;
44129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44130 if (!SWIG_IsOK(res1)) {
44131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44132 }
44133 arg1 = reinterpret_cast< wxMenu * >(argp1);
44134 {
44135 PyThreadState* __tstate = wxPyBeginAllowThreads();
44136 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44137 wxPyEndAllowThreads(__tstate);
44138 if (PyErr_Occurred()) SWIG_fail;
44139 }
44140 {
44141 resultobj = wxPyMake_wxObject(result, (bool)0);
44142 }
44143 return resultobj;
44144 fail:
44145 return NULL;
44146 }
44147
44148
44149 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44150 PyObject *resultobj = 0;
44151 wxMenu *arg1 = (wxMenu *) 0 ;
44152 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44153 void *argp1 = 0 ;
44154 int res1 = 0 ;
44155 void *argp2 = 0 ;
44156 int res2 = 0 ;
44157 PyObject * obj0 = 0 ;
44158 PyObject * obj1 = 0 ;
44159 char * kwnames[] = {
44160 (char *) "self",(char *) "menubar", NULL
44161 };
44162
44163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44165 if (!SWIG_IsOK(res1)) {
44166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44167 }
44168 arg1 = reinterpret_cast< wxMenu * >(argp1);
44169 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44170 if (!SWIG_IsOK(res2)) {
44171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44172 }
44173 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44174 {
44175 PyThreadState* __tstate = wxPyBeginAllowThreads();
44176 (arg1)->Attach(arg2);
44177 wxPyEndAllowThreads(__tstate);
44178 if (PyErr_Occurred()) SWIG_fail;
44179 }
44180 resultobj = SWIG_Py_Void();
44181 return resultobj;
44182 fail:
44183 return NULL;
44184 }
44185
44186
44187 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44188 PyObject *resultobj = 0;
44189 wxMenu *arg1 = (wxMenu *) 0 ;
44190 void *argp1 = 0 ;
44191 int res1 = 0 ;
44192 PyObject *swig_obj[1] ;
44193
44194 if (!args) SWIG_fail;
44195 swig_obj[0] = args;
44196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44197 if (!SWIG_IsOK(res1)) {
44198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44199 }
44200 arg1 = reinterpret_cast< wxMenu * >(argp1);
44201 {
44202 PyThreadState* __tstate = wxPyBeginAllowThreads();
44203 (arg1)->Detach();
44204 wxPyEndAllowThreads(__tstate);
44205 if (PyErr_Occurred()) SWIG_fail;
44206 }
44207 resultobj = SWIG_Py_Void();
44208 return resultobj;
44209 fail:
44210 return NULL;
44211 }
44212
44213
44214 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44215 PyObject *resultobj = 0;
44216 wxMenu *arg1 = (wxMenu *) 0 ;
44217 bool result;
44218 void *argp1 = 0 ;
44219 int res1 = 0 ;
44220 PyObject *swig_obj[1] ;
44221
44222 if (!args) SWIG_fail;
44223 swig_obj[0] = args;
44224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44225 if (!SWIG_IsOK(res1)) {
44226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44227 }
44228 arg1 = reinterpret_cast< wxMenu * >(argp1);
44229 {
44230 PyThreadState* __tstate = wxPyBeginAllowThreads();
44231 result = (bool)((wxMenu const *)arg1)->IsAttached();
44232 wxPyEndAllowThreads(__tstate);
44233 if (PyErr_Occurred()) SWIG_fail;
44234 }
44235 {
44236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44237 }
44238 return resultobj;
44239 fail:
44240 return NULL;
44241 }
44242
44243
44244 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44245 PyObject *resultobj = 0;
44246 wxMenu *arg1 = (wxMenu *) 0 ;
44247 wxMenu *arg2 = (wxMenu *) 0 ;
44248 void *argp1 = 0 ;
44249 int res1 = 0 ;
44250 void *argp2 = 0 ;
44251 int res2 = 0 ;
44252 PyObject * obj0 = 0 ;
44253 PyObject * obj1 = 0 ;
44254 char * kwnames[] = {
44255 (char *) "self",(char *) "parent", NULL
44256 };
44257
44258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44260 if (!SWIG_IsOK(res1)) {
44261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44262 }
44263 arg1 = reinterpret_cast< wxMenu * >(argp1);
44264 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44265 if (!SWIG_IsOK(res2)) {
44266 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44267 }
44268 arg2 = reinterpret_cast< wxMenu * >(argp2);
44269 {
44270 PyThreadState* __tstate = wxPyBeginAllowThreads();
44271 (arg1)->SetParent(arg2);
44272 wxPyEndAllowThreads(__tstate);
44273 if (PyErr_Occurred()) SWIG_fail;
44274 }
44275 resultobj = SWIG_Py_Void();
44276 return resultobj;
44277 fail:
44278 return NULL;
44279 }
44280
44281
44282 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44283 PyObject *resultobj = 0;
44284 wxMenu *arg1 = (wxMenu *) 0 ;
44285 wxMenu *result = 0 ;
44286 void *argp1 = 0 ;
44287 int res1 = 0 ;
44288 PyObject *swig_obj[1] ;
44289
44290 if (!args) SWIG_fail;
44291 swig_obj[0] = args;
44292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44293 if (!SWIG_IsOK(res1)) {
44294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44295 }
44296 arg1 = reinterpret_cast< wxMenu * >(argp1);
44297 {
44298 PyThreadState* __tstate = wxPyBeginAllowThreads();
44299 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44300 wxPyEndAllowThreads(__tstate);
44301 if (PyErr_Occurred()) SWIG_fail;
44302 }
44303 {
44304 resultobj = wxPyMake_wxObject(result, 0);
44305 }
44306 return resultobj;
44307 fail:
44308 return NULL;
44309 }
44310
44311
44312 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44313 PyObject *obj;
44314 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44315 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44316 return SWIG_Py_Void();
44317 }
44318
44319 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44320 return SWIG_Python_InitShadowInstance(args);
44321 }
44322
44323 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44324 PyObject *resultobj = 0;
44325 long arg1 = (long) 0 ;
44326 wxMenuBar *result = 0 ;
44327 long val1 ;
44328 int ecode1 = 0 ;
44329 PyObject * obj0 = 0 ;
44330 char * kwnames[] = {
44331 (char *) "style", NULL
44332 };
44333
44334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44335 if (obj0) {
44336 ecode1 = SWIG_AsVal_long(obj0, &val1);
44337 if (!SWIG_IsOK(ecode1)) {
44338 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44339 }
44340 arg1 = static_cast< long >(val1);
44341 }
44342 {
44343 if (!wxPyCheckForApp()) SWIG_fail;
44344 PyThreadState* __tstate = wxPyBeginAllowThreads();
44345 result = (wxMenuBar *)new wxMenuBar(arg1);
44346 wxPyEndAllowThreads(__tstate);
44347 if (PyErr_Occurred()) SWIG_fail;
44348 }
44349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44350 return resultobj;
44351 fail:
44352 return NULL;
44353 }
44354
44355
44356 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44357 PyObject *resultobj = 0;
44358 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44359 wxMenu *arg2 = (wxMenu *) 0 ;
44360 wxString *arg3 = 0 ;
44361 bool result;
44362 void *argp1 = 0 ;
44363 int res1 = 0 ;
44364 void *argp2 = 0 ;
44365 int res2 = 0 ;
44366 bool temp3 = false ;
44367 PyObject * obj0 = 0 ;
44368 PyObject * obj1 = 0 ;
44369 PyObject * obj2 = 0 ;
44370 char * kwnames[] = {
44371 (char *) "self",(char *) "menu",(char *) "title", NULL
44372 };
44373
44374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44376 if (!SWIG_IsOK(res1)) {
44377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44378 }
44379 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44380 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44381 if (!SWIG_IsOK(res2)) {
44382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44383 }
44384 arg2 = reinterpret_cast< wxMenu * >(argp2);
44385 {
44386 arg3 = wxString_in_helper(obj2);
44387 if (arg3 == NULL) SWIG_fail;
44388 temp3 = true;
44389 }
44390 {
44391 PyThreadState* __tstate = wxPyBeginAllowThreads();
44392 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44393 wxPyEndAllowThreads(__tstate);
44394 if (PyErr_Occurred()) SWIG_fail;
44395 }
44396 {
44397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44398 }
44399 {
44400 if (temp3)
44401 delete arg3;
44402 }
44403 return resultobj;
44404 fail:
44405 {
44406 if (temp3)
44407 delete arg3;
44408 }
44409 return NULL;
44410 }
44411
44412
44413 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44414 PyObject *resultobj = 0;
44415 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44416 size_t arg2 ;
44417 wxMenu *arg3 = (wxMenu *) 0 ;
44418 wxString *arg4 = 0 ;
44419 bool result;
44420 void *argp1 = 0 ;
44421 int res1 = 0 ;
44422 size_t val2 ;
44423 int ecode2 = 0 ;
44424 void *argp3 = 0 ;
44425 int res3 = 0 ;
44426 bool temp4 = false ;
44427 PyObject * obj0 = 0 ;
44428 PyObject * obj1 = 0 ;
44429 PyObject * obj2 = 0 ;
44430 PyObject * obj3 = 0 ;
44431 char * kwnames[] = {
44432 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44433 };
44434
44435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44437 if (!SWIG_IsOK(res1)) {
44438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44439 }
44440 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44441 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44442 if (!SWIG_IsOK(ecode2)) {
44443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44444 }
44445 arg2 = static_cast< size_t >(val2);
44446 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44447 if (!SWIG_IsOK(res3)) {
44448 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44449 }
44450 arg3 = reinterpret_cast< wxMenu * >(argp3);
44451 {
44452 arg4 = wxString_in_helper(obj3);
44453 if (arg4 == NULL) SWIG_fail;
44454 temp4 = true;
44455 }
44456 {
44457 PyThreadState* __tstate = wxPyBeginAllowThreads();
44458 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44459 wxPyEndAllowThreads(__tstate);
44460 if (PyErr_Occurred()) SWIG_fail;
44461 }
44462 {
44463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44464 }
44465 {
44466 if (temp4)
44467 delete arg4;
44468 }
44469 return resultobj;
44470 fail:
44471 {
44472 if (temp4)
44473 delete arg4;
44474 }
44475 return NULL;
44476 }
44477
44478
44479 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44480 PyObject *resultobj = 0;
44481 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44482 size_t result;
44483 void *argp1 = 0 ;
44484 int res1 = 0 ;
44485 PyObject *swig_obj[1] ;
44486
44487 if (!args) SWIG_fail;
44488 swig_obj[0] = args;
44489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44490 if (!SWIG_IsOK(res1)) {
44491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44492 }
44493 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44494 {
44495 PyThreadState* __tstate = wxPyBeginAllowThreads();
44496 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44497 wxPyEndAllowThreads(__tstate);
44498 if (PyErr_Occurred()) SWIG_fail;
44499 }
44500 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44501 return resultobj;
44502 fail:
44503 return NULL;
44504 }
44505
44506
44507 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44508 PyObject *resultobj = 0;
44509 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44510 size_t arg2 ;
44511 wxMenu *result = 0 ;
44512 void *argp1 = 0 ;
44513 int res1 = 0 ;
44514 size_t val2 ;
44515 int ecode2 = 0 ;
44516 PyObject * obj0 = 0 ;
44517 PyObject * obj1 = 0 ;
44518 char * kwnames[] = {
44519 (char *) "self",(char *) "pos", NULL
44520 };
44521
44522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44524 if (!SWIG_IsOK(res1)) {
44525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44526 }
44527 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44528 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44529 if (!SWIG_IsOK(ecode2)) {
44530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44531 }
44532 arg2 = static_cast< size_t >(val2);
44533 {
44534 PyThreadState* __tstate = wxPyBeginAllowThreads();
44535 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44536 wxPyEndAllowThreads(__tstate);
44537 if (PyErr_Occurred()) SWIG_fail;
44538 }
44539 {
44540 resultobj = wxPyMake_wxObject(result, 0);
44541 }
44542 return resultobj;
44543 fail:
44544 return NULL;
44545 }
44546
44547
44548 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44549 PyObject *resultobj = 0;
44550 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44551 size_t arg2 ;
44552 wxMenu *arg3 = (wxMenu *) 0 ;
44553 wxString *arg4 = 0 ;
44554 wxMenu *result = 0 ;
44555 void *argp1 = 0 ;
44556 int res1 = 0 ;
44557 size_t val2 ;
44558 int ecode2 = 0 ;
44559 void *argp3 = 0 ;
44560 int res3 = 0 ;
44561 bool temp4 = false ;
44562 PyObject * obj0 = 0 ;
44563 PyObject * obj1 = 0 ;
44564 PyObject * obj2 = 0 ;
44565 PyObject * obj3 = 0 ;
44566 char * kwnames[] = {
44567 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44568 };
44569
44570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44572 if (!SWIG_IsOK(res1)) {
44573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44574 }
44575 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44576 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44577 if (!SWIG_IsOK(ecode2)) {
44578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44579 }
44580 arg2 = static_cast< size_t >(val2);
44581 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44582 if (!SWIG_IsOK(res3)) {
44583 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44584 }
44585 arg3 = reinterpret_cast< wxMenu * >(argp3);
44586 {
44587 arg4 = wxString_in_helper(obj3);
44588 if (arg4 == NULL) SWIG_fail;
44589 temp4 = true;
44590 }
44591 {
44592 PyThreadState* __tstate = wxPyBeginAllowThreads();
44593 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44594 wxPyEndAllowThreads(__tstate);
44595 if (PyErr_Occurred()) SWIG_fail;
44596 }
44597 {
44598 resultobj = wxPyMake_wxObject(result, 0);
44599 }
44600 {
44601 if (temp4)
44602 delete arg4;
44603 }
44604 return resultobj;
44605 fail:
44606 {
44607 if (temp4)
44608 delete arg4;
44609 }
44610 return NULL;
44611 }
44612
44613
44614 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44615 PyObject *resultobj = 0;
44616 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44617 size_t arg2 ;
44618 wxMenu *result = 0 ;
44619 void *argp1 = 0 ;
44620 int res1 = 0 ;
44621 size_t val2 ;
44622 int ecode2 = 0 ;
44623 PyObject * obj0 = 0 ;
44624 PyObject * obj1 = 0 ;
44625 char * kwnames[] = {
44626 (char *) "self",(char *) "pos", NULL
44627 };
44628
44629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44631 if (!SWIG_IsOK(res1)) {
44632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44633 }
44634 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44635 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44636 if (!SWIG_IsOK(ecode2)) {
44637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
44638 }
44639 arg2 = static_cast< size_t >(val2);
44640 {
44641 PyThreadState* __tstate = wxPyBeginAllowThreads();
44642 result = (wxMenu *)(arg1)->Remove(arg2);
44643 wxPyEndAllowThreads(__tstate);
44644 if (PyErr_Occurred()) SWIG_fail;
44645 }
44646 {
44647 resultobj = wxPyMake_wxObject(result, 0);
44648 }
44649 return resultobj;
44650 fail:
44651 return NULL;
44652 }
44653
44654
44655 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44656 PyObject *resultobj = 0;
44657 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44658 size_t arg2 ;
44659 bool arg3 ;
44660 void *argp1 = 0 ;
44661 int res1 = 0 ;
44662 size_t val2 ;
44663 int ecode2 = 0 ;
44664 bool val3 ;
44665 int ecode3 = 0 ;
44666 PyObject * obj0 = 0 ;
44667 PyObject * obj1 = 0 ;
44668 PyObject * obj2 = 0 ;
44669 char * kwnames[] = {
44670 (char *) "self",(char *) "pos",(char *) "enable", NULL
44671 };
44672
44673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44675 if (!SWIG_IsOK(res1)) {
44676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44677 }
44678 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44679 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44680 if (!SWIG_IsOK(ecode2)) {
44681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
44682 }
44683 arg2 = static_cast< size_t >(val2);
44684 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44685 if (!SWIG_IsOK(ecode3)) {
44686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
44687 }
44688 arg3 = static_cast< bool >(val3);
44689 {
44690 PyThreadState* __tstate = wxPyBeginAllowThreads();
44691 (arg1)->EnableTop(arg2,arg3);
44692 wxPyEndAllowThreads(__tstate);
44693 if (PyErr_Occurred()) SWIG_fail;
44694 }
44695 resultobj = SWIG_Py_Void();
44696 return resultobj;
44697 fail:
44698 return NULL;
44699 }
44700
44701
44702 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44703 PyObject *resultobj = 0;
44704 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44705 size_t arg2 ;
44706 bool result;
44707 void *argp1 = 0 ;
44708 int res1 = 0 ;
44709 size_t val2 ;
44710 int ecode2 = 0 ;
44711 PyObject * obj0 = 0 ;
44712 PyObject * obj1 = 0 ;
44713 char * kwnames[] = {
44714 (char *) "self",(char *) "pos", NULL
44715 };
44716
44717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
44718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44719 if (!SWIG_IsOK(res1)) {
44720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44721 }
44722 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44723 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44724 if (!SWIG_IsOK(ecode2)) {
44725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
44726 }
44727 arg2 = static_cast< size_t >(val2);
44728 {
44729 PyThreadState* __tstate = wxPyBeginAllowThreads();
44730 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
44731 wxPyEndAllowThreads(__tstate);
44732 if (PyErr_Occurred()) SWIG_fail;
44733 }
44734 {
44735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44736 }
44737 return resultobj;
44738 fail:
44739 return NULL;
44740 }
44741
44742
44743 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44744 PyObject *resultobj = 0;
44745 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44746 size_t arg2 ;
44747 wxString *arg3 = 0 ;
44748 void *argp1 = 0 ;
44749 int res1 = 0 ;
44750 size_t val2 ;
44751 int ecode2 = 0 ;
44752 bool temp3 = false ;
44753 PyObject * obj0 = 0 ;
44754 PyObject * obj1 = 0 ;
44755 PyObject * obj2 = 0 ;
44756 char * kwnames[] = {
44757 (char *) "self",(char *) "pos",(char *) "label", NULL
44758 };
44759
44760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44762 if (!SWIG_IsOK(res1)) {
44763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44764 }
44765 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44766 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44767 if (!SWIG_IsOK(ecode2)) {
44768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44769 }
44770 arg2 = static_cast< size_t >(val2);
44771 {
44772 arg3 = wxString_in_helper(obj2);
44773 if (arg3 == NULL) SWIG_fail;
44774 temp3 = true;
44775 }
44776 {
44777 PyThreadState* __tstate = wxPyBeginAllowThreads();
44778 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
44779 wxPyEndAllowThreads(__tstate);
44780 if (PyErr_Occurred()) SWIG_fail;
44781 }
44782 resultobj = SWIG_Py_Void();
44783 {
44784 if (temp3)
44785 delete arg3;
44786 }
44787 return resultobj;
44788 fail:
44789 {
44790 if (temp3)
44791 delete arg3;
44792 }
44793 return NULL;
44794 }
44795
44796
44797 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44798 PyObject *resultobj = 0;
44799 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44800 size_t arg2 ;
44801 wxString result;
44802 void *argp1 = 0 ;
44803 int res1 = 0 ;
44804 size_t val2 ;
44805 int ecode2 = 0 ;
44806 PyObject * obj0 = 0 ;
44807 PyObject * obj1 = 0 ;
44808 char * kwnames[] = {
44809 (char *) "self",(char *) "pos", NULL
44810 };
44811
44812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
44813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44814 if (!SWIG_IsOK(res1)) {
44815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44816 }
44817 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44818 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44819 if (!SWIG_IsOK(ecode2)) {
44820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44821 }
44822 arg2 = static_cast< size_t >(val2);
44823 {
44824 PyThreadState* __tstate = wxPyBeginAllowThreads();
44825 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
44826 wxPyEndAllowThreads(__tstate);
44827 if (PyErr_Occurred()) SWIG_fail;
44828 }
44829 {
44830 #if wxUSE_UNICODE
44831 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44832 #else
44833 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44834 #endif
44835 }
44836 return resultobj;
44837 fail:
44838 return NULL;
44839 }
44840
44841
44842 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44843 PyObject *resultobj = 0;
44844 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44845 wxString *arg2 = 0 ;
44846 wxString *arg3 = 0 ;
44847 int result;
44848 void *argp1 = 0 ;
44849 int res1 = 0 ;
44850 bool temp2 = false ;
44851 bool temp3 = false ;
44852 PyObject * obj0 = 0 ;
44853 PyObject * obj1 = 0 ;
44854 PyObject * obj2 = 0 ;
44855 char * kwnames[] = {
44856 (char *) "self",(char *) "menu",(char *) "item", NULL
44857 };
44858
44859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44861 if (!SWIG_IsOK(res1)) {
44862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44863 }
44864 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44865 {
44866 arg2 = wxString_in_helper(obj1);
44867 if (arg2 == NULL) SWIG_fail;
44868 temp2 = true;
44869 }
44870 {
44871 arg3 = wxString_in_helper(obj2);
44872 if (arg3 == NULL) SWIG_fail;
44873 temp3 = true;
44874 }
44875 {
44876 PyThreadState* __tstate = wxPyBeginAllowThreads();
44877 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
44878 wxPyEndAllowThreads(__tstate);
44879 if (PyErr_Occurred()) SWIG_fail;
44880 }
44881 resultobj = SWIG_From_int(static_cast< int >(result));
44882 {
44883 if (temp2)
44884 delete arg2;
44885 }
44886 {
44887 if (temp3)
44888 delete arg3;
44889 }
44890 return resultobj;
44891 fail:
44892 {
44893 if (temp2)
44894 delete arg2;
44895 }
44896 {
44897 if (temp3)
44898 delete arg3;
44899 }
44900 return NULL;
44901 }
44902
44903
44904 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44905 PyObject *resultobj = 0;
44906 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44907 int arg2 ;
44908 wxMenuItem *result = 0 ;
44909 void *argp1 = 0 ;
44910 int res1 = 0 ;
44911 int val2 ;
44912 int ecode2 = 0 ;
44913 PyObject * obj0 = 0 ;
44914 PyObject * obj1 = 0 ;
44915 char * kwnames[] = {
44916 (char *) "self",(char *) "id", NULL
44917 };
44918
44919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
44920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44921 if (!SWIG_IsOK(res1)) {
44922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44923 }
44924 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44925 ecode2 = SWIG_AsVal_int(obj1, &val2);
44926 if (!SWIG_IsOK(ecode2)) {
44927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
44928 }
44929 arg2 = static_cast< int >(val2);
44930 {
44931 PyThreadState* __tstate = wxPyBeginAllowThreads();
44932 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
44933 wxPyEndAllowThreads(__tstate);
44934 if (PyErr_Occurred()) SWIG_fail;
44935 }
44936 {
44937 resultobj = wxPyMake_wxObject(result, (bool)0);
44938 }
44939 return resultobj;
44940 fail:
44941 return NULL;
44942 }
44943
44944
44945 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44946 PyObject *resultobj = 0;
44947 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44948 wxString *arg2 = 0 ;
44949 int result;
44950 void *argp1 = 0 ;
44951 int res1 = 0 ;
44952 bool temp2 = false ;
44953 PyObject * obj0 = 0 ;
44954 PyObject * obj1 = 0 ;
44955 char * kwnames[] = {
44956 (char *) "self",(char *) "title", NULL
44957 };
44958
44959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44961 if (!SWIG_IsOK(res1)) {
44962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44963 }
44964 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44965 {
44966 arg2 = wxString_in_helper(obj1);
44967 if (arg2 == NULL) SWIG_fail;
44968 temp2 = true;
44969 }
44970 {
44971 PyThreadState* __tstate = wxPyBeginAllowThreads();
44972 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
44973 wxPyEndAllowThreads(__tstate);
44974 if (PyErr_Occurred()) SWIG_fail;
44975 }
44976 resultobj = SWIG_From_int(static_cast< int >(result));
44977 {
44978 if (temp2)
44979 delete arg2;
44980 }
44981 return resultobj;
44982 fail:
44983 {
44984 if (temp2)
44985 delete arg2;
44986 }
44987 return NULL;
44988 }
44989
44990
44991 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44992 PyObject *resultobj = 0;
44993 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44994 int arg2 ;
44995 bool arg3 ;
44996 void *argp1 = 0 ;
44997 int res1 = 0 ;
44998 int val2 ;
44999 int ecode2 = 0 ;
45000 bool val3 ;
45001 int ecode3 = 0 ;
45002 PyObject * obj0 = 0 ;
45003 PyObject * obj1 = 0 ;
45004 PyObject * obj2 = 0 ;
45005 char * kwnames[] = {
45006 (char *) "self",(char *) "id",(char *) "enable", NULL
45007 };
45008
45009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45011 if (!SWIG_IsOK(res1)) {
45012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45013 }
45014 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45015 ecode2 = SWIG_AsVal_int(obj1, &val2);
45016 if (!SWIG_IsOK(ecode2)) {
45017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45018 }
45019 arg2 = static_cast< int >(val2);
45020 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45021 if (!SWIG_IsOK(ecode3)) {
45022 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45023 }
45024 arg3 = static_cast< bool >(val3);
45025 {
45026 PyThreadState* __tstate = wxPyBeginAllowThreads();
45027 (arg1)->Enable(arg2,arg3);
45028 wxPyEndAllowThreads(__tstate);
45029 if (PyErr_Occurred()) SWIG_fail;
45030 }
45031 resultobj = SWIG_Py_Void();
45032 return resultobj;
45033 fail:
45034 return NULL;
45035 }
45036
45037
45038 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45039 PyObject *resultobj = 0;
45040 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45041 int arg2 ;
45042 bool arg3 ;
45043 void *argp1 = 0 ;
45044 int res1 = 0 ;
45045 int val2 ;
45046 int ecode2 = 0 ;
45047 bool val3 ;
45048 int ecode3 = 0 ;
45049 PyObject * obj0 = 0 ;
45050 PyObject * obj1 = 0 ;
45051 PyObject * obj2 = 0 ;
45052 char * kwnames[] = {
45053 (char *) "self",(char *) "id",(char *) "check", NULL
45054 };
45055
45056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45058 if (!SWIG_IsOK(res1)) {
45059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45060 }
45061 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45062 ecode2 = SWIG_AsVal_int(obj1, &val2);
45063 if (!SWIG_IsOK(ecode2)) {
45064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45065 }
45066 arg2 = static_cast< int >(val2);
45067 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45068 if (!SWIG_IsOK(ecode3)) {
45069 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45070 }
45071 arg3 = static_cast< bool >(val3);
45072 {
45073 PyThreadState* __tstate = wxPyBeginAllowThreads();
45074 (arg1)->Check(arg2,arg3);
45075 wxPyEndAllowThreads(__tstate);
45076 if (PyErr_Occurred()) SWIG_fail;
45077 }
45078 resultobj = SWIG_Py_Void();
45079 return resultobj;
45080 fail:
45081 return NULL;
45082 }
45083
45084
45085 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45086 PyObject *resultobj = 0;
45087 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45088 int arg2 ;
45089 bool result;
45090 void *argp1 = 0 ;
45091 int res1 = 0 ;
45092 int val2 ;
45093 int ecode2 = 0 ;
45094 PyObject * obj0 = 0 ;
45095 PyObject * obj1 = 0 ;
45096 char * kwnames[] = {
45097 (char *) "self",(char *) "id", NULL
45098 };
45099
45100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45102 if (!SWIG_IsOK(res1)) {
45103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45104 }
45105 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45106 ecode2 = SWIG_AsVal_int(obj1, &val2);
45107 if (!SWIG_IsOK(ecode2)) {
45108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45109 }
45110 arg2 = static_cast< int >(val2);
45111 {
45112 PyThreadState* __tstate = wxPyBeginAllowThreads();
45113 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45114 wxPyEndAllowThreads(__tstate);
45115 if (PyErr_Occurred()) SWIG_fail;
45116 }
45117 {
45118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45119 }
45120 return resultobj;
45121 fail:
45122 return NULL;
45123 }
45124
45125
45126 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45127 PyObject *resultobj = 0;
45128 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45129 int arg2 ;
45130 bool result;
45131 void *argp1 = 0 ;
45132 int res1 = 0 ;
45133 int val2 ;
45134 int ecode2 = 0 ;
45135 PyObject * obj0 = 0 ;
45136 PyObject * obj1 = 0 ;
45137 char * kwnames[] = {
45138 (char *) "self",(char *) "id", NULL
45139 };
45140
45141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45143 if (!SWIG_IsOK(res1)) {
45144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45145 }
45146 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45147 ecode2 = SWIG_AsVal_int(obj1, &val2);
45148 if (!SWIG_IsOK(ecode2)) {
45149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45150 }
45151 arg2 = static_cast< int >(val2);
45152 {
45153 PyThreadState* __tstate = wxPyBeginAllowThreads();
45154 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45155 wxPyEndAllowThreads(__tstate);
45156 if (PyErr_Occurred()) SWIG_fail;
45157 }
45158 {
45159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45160 }
45161 return resultobj;
45162 fail:
45163 return NULL;
45164 }
45165
45166
45167 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45168 PyObject *resultobj = 0;
45169 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45170 int arg2 ;
45171 wxString *arg3 = 0 ;
45172 void *argp1 = 0 ;
45173 int res1 = 0 ;
45174 int val2 ;
45175 int ecode2 = 0 ;
45176 bool temp3 = false ;
45177 PyObject * obj0 = 0 ;
45178 PyObject * obj1 = 0 ;
45179 PyObject * obj2 = 0 ;
45180 char * kwnames[] = {
45181 (char *) "self",(char *) "id",(char *) "label", NULL
45182 };
45183
45184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45186 if (!SWIG_IsOK(res1)) {
45187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45188 }
45189 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45190 ecode2 = SWIG_AsVal_int(obj1, &val2);
45191 if (!SWIG_IsOK(ecode2)) {
45192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45193 }
45194 arg2 = static_cast< int >(val2);
45195 {
45196 arg3 = wxString_in_helper(obj2);
45197 if (arg3 == NULL) SWIG_fail;
45198 temp3 = true;
45199 }
45200 {
45201 PyThreadState* __tstate = wxPyBeginAllowThreads();
45202 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45203 wxPyEndAllowThreads(__tstate);
45204 if (PyErr_Occurred()) SWIG_fail;
45205 }
45206 resultobj = SWIG_Py_Void();
45207 {
45208 if (temp3)
45209 delete arg3;
45210 }
45211 return resultobj;
45212 fail:
45213 {
45214 if (temp3)
45215 delete arg3;
45216 }
45217 return NULL;
45218 }
45219
45220
45221 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45222 PyObject *resultobj = 0;
45223 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45224 int arg2 ;
45225 wxString result;
45226 void *argp1 = 0 ;
45227 int res1 = 0 ;
45228 int val2 ;
45229 int ecode2 = 0 ;
45230 PyObject * obj0 = 0 ;
45231 PyObject * obj1 = 0 ;
45232 char * kwnames[] = {
45233 (char *) "self",(char *) "id", NULL
45234 };
45235
45236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45238 if (!SWIG_IsOK(res1)) {
45239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45240 }
45241 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45242 ecode2 = SWIG_AsVal_int(obj1, &val2);
45243 if (!SWIG_IsOK(ecode2)) {
45244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45245 }
45246 arg2 = static_cast< int >(val2);
45247 {
45248 PyThreadState* __tstate = wxPyBeginAllowThreads();
45249 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45250 wxPyEndAllowThreads(__tstate);
45251 if (PyErr_Occurred()) SWIG_fail;
45252 }
45253 {
45254 #if wxUSE_UNICODE
45255 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45256 #else
45257 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45258 #endif
45259 }
45260 return resultobj;
45261 fail:
45262 return NULL;
45263 }
45264
45265
45266 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45267 PyObject *resultobj = 0;
45268 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45269 int arg2 ;
45270 wxString *arg3 = 0 ;
45271 void *argp1 = 0 ;
45272 int res1 = 0 ;
45273 int val2 ;
45274 int ecode2 = 0 ;
45275 bool temp3 = false ;
45276 PyObject * obj0 = 0 ;
45277 PyObject * obj1 = 0 ;
45278 PyObject * obj2 = 0 ;
45279 char * kwnames[] = {
45280 (char *) "self",(char *) "id",(char *) "helpString", NULL
45281 };
45282
45283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45285 if (!SWIG_IsOK(res1)) {
45286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45287 }
45288 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45289 ecode2 = SWIG_AsVal_int(obj1, &val2);
45290 if (!SWIG_IsOK(ecode2)) {
45291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45292 }
45293 arg2 = static_cast< int >(val2);
45294 {
45295 arg3 = wxString_in_helper(obj2);
45296 if (arg3 == NULL) SWIG_fail;
45297 temp3 = true;
45298 }
45299 {
45300 PyThreadState* __tstate = wxPyBeginAllowThreads();
45301 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45302 wxPyEndAllowThreads(__tstate);
45303 if (PyErr_Occurred()) SWIG_fail;
45304 }
45305 resultobj = SWIG_Py_Void();
45306 {
45307 if (temp3)
45308 delete arg3;
45309 }
45310 return resultobj;
45311 fail:
45312 {
45313 if (temp3)
45314 delete arg3;
45315 }
45316 return NULL;
45317 }
45318
45319
45320 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45321 PyObject *resultobj = 0;
45322 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45323 int arg2 ;
45324 wxString result;
45325 void *argp1 = 0 ;
45326 int res1 = 0 ;
45327 int val2 ;
45328 int ecode2 = 0 ;
45329 PyObject * obj0 = 0 ;
45330 PyObject * obj1 = 0 ;
45331 char * kwnames[] = {
45332 (char *) "self",(char *) "id", NULL
45333 };
45334
45335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45337 if (!SWIG_IsOK(res1)) {
45338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45339 }
45340 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45341 ecode2 = SWIG_AsVal_int(obj1, &val2);
45342 if (!SWIG_IsOK(ecode2)) {
45343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45344 }
45345 arg2 = static_cast< int >(val2);
45346 {
45347 PyThreadState* __tstate = wxPyBeginAllowThreads();
45348 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45349 wxPyEndAllowThreads(__tstate);
45350 if (PyErr_Occurred()) SWIG_fail;
45351 }
45352 {
45353 #if wxUSE_UNICODE
45354 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45355 #else
45356 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45357 #endif
45358 }
45359 return resultobj;
45360 fail:
45361 return NULL;
45362 }
45363
45364
45365 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45366 PyObject *resultobj = 0;
45367 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45368 wxFrame *result = 0 ;
45369 void *argp1 = 0 ;
45370 int res1 = 0 ;
45371 PyObject *swig_obj[1] ;
45372
45373 if (!args) SWIG_fail;
45374 swig_obj[0] = args;
45375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45376 if (!SWIG_IsOK(res1)) {
45377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45378 }
45379 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45380 {
45381 PyThreadState* __tstate = wxPyBeginAllowThreads();
45382 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45383 wxPyEndAllowThreads(__tstate);
45384 if (PyErr_Occurred()) SWIG_fail;
45385 }
45386 {
45387 resultobj = wxPyMake_wxObject(result, (bool)0);
45388 }
45389 return resultobj;
45390 fail:
45391 return NULL;
45392 }
45393
45394
45395 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45396 PyObject *resultobj = 0;
45397 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45398 bool result;
45399 void *argp1 = 0 ;
45400 int res1 = 0 ;
45401 PyObject *swig_obj[1] ;
45402
45403 if (!args) SWIG_fail;
45404 swig_obj[0] = args;
45405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45406 if (!SWIG_IsOK(res1)) {
45407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45408 }
45409 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45410 {
45411 PyThreadState* __tstate = wxPyBeginAllowThreads();
45412 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45413 wxPyEndAllowThreads(__tstate);
45414 if (PyErr_Occurred()) SWIG_fail;
45415 }
45416 {
45417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45418 }
45419 return resultobj;
45420 fail:
45421 return NULL;
45422 }
45423
45424
45425 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45426 PyObject *resultobj = 0;
45427 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45428 wxFrame *arg2 = (wxFrame *) 0 ;
45429 void *argp1 = 0 ;
45430 int res1 = 0 ;
45431 void *argp2 = 0 ;
45432 int res2 = 0 ;
45433 PyObject * obj0 = 0 ;
45434 PyObject * obj1 = 0 ;
45435 char * kwnames[] = {
45436 (char *) "self",(char *) "frame", NULL
45437 };
45438
45439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45441 if (!SWIG_IsOK(res1)) {
45442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45443 }
45444 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45445 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45446 if (!SWIG_IsOK(res2)) {
45447 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45448 }
45449 arg2 = reinterpret_cast< wxFrame * >(argp2);
45450 {
45451 PyThreadState* __tstate = wxPyBeginAllowThreads();
45452 (arg1)->Attach(arg2);
45453 wxPyEndAllowThreads(__tstate);
45454 if (PyErr_Occurred()) SWIG_fail;
45455 }
45456 resultobj = SWIG_Py_Void();
45457 return resultobj;
45458 fail:
45459 return NULL;
45460 }
45461
45462
45463 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45464 PyObject *resultobj = 0;
45465 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45466 void *argp1 = 0 ;
45467 int res1 = 0 ;
45468 PyObject *swig_obj[1] ;
45469
45470 if (!args) SWIG_fail;
45471 swig_obj[0] = args;
45472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45473 if (!SWIG_IsOK(res1)) {
45474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45475 }
45476 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45477 {
45478 PyThreadState* __tstate = wxPyBeginAllowThreads();
45479 (arg1)->Detach();
45480 wxPyEndAllowThreads(__tstate);
45481 if (PyErr_Occurred()) SWIG_fail;
45482 }
45483 resultobj = SWIG_Py_Void();
45484 return resultobj;
45485 fail:
45486 return NULL;
45487 }
45488
45489
45490 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45491 PyObject *resultobj = 0;
45492 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45493 void *argp1 = 0 ;
45494 int res1 = 0 ;
45495 PyObject *swig_obj[1] ;
45496
45497 if (!args) SWIG_fail;
45498 swig_obj[0] = args;
45499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45500 if (!SWIG_IsOK(res1)) {
45501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45502 }
45503 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45504 {
45505 PyThreadState* __tstate = wxPyBeginAllowThreads();
45506 (arg1)->UpdateMenus();
45507 wxPyEndAllowThreads(__tstate);
45508 if (PyErr_Occurred()) SWIG_fail;
45509 }
45510 resultobj = SWIG_Py_Void();
45511 return resultobj;
45512 fail:
45513 return NULL;
45514 }
45515
45516
45517 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45518 PyObject *resultobj = 0;
45519 bool arg1 ;
45520 bool val1 ;
45521 int ecode1 = 0 ;
45522 PyObject * obj0 = 0 ;
45523 char * kwnames[] = {
45524 (char *) "enable", NULL
45525 };
45526
45527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45528 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45529 if (!SWIG_IsOK(ecode1)) {
45530 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45531 }
45532 arg1 = static_cast< bool >(val1);
45533 {
45534 PyThreadState* __tstate = wxPyBeginAllowThreads();
45535 wxMenuBar_SetAutoWindowMenu(arg1);
45536 wxPyEndAllowThreads(__tstate);
45537 if (PyErr_Occurred()) SWIG_fail;
45538 }
45539 resultobj = SWIG_Py_Void();
45540 return resultobj;
45541 fail:
45542 return NULL;
45543 }
45544
45545
45546 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45547 PyObject *resultobj = 0;
45548 bool result;
45549
45550 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45551 {
45552 PyThreadState* __tstate = wxPyBeginAllowThreads();
45553 result = (bool)wxMenuBar_GetAutoWindowMenu();
45554 wxPyEndAllowThreads(__tstate);
45555 if (PyErr_Occurred()) SWIG_fail;
45556 }
45557 {
45558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45559 }
45560 return resultobj;
45561 fail:
45562 return NULL;
45563 }
45564
45565
45566 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45567 PyObject *obj;
45568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45569 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45570 return SWIG_Py_Void();
45571 }
45572
45573 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45574 return SWIG_Python_InitShadowInstance(args);
45575 }
45576
45577 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45578 PyObject *resultobj = 0;
45579 wxMenu *arg1 = (wxMenu *) NULL ;
45580 int arg2 = (int) wxID_ANY ;
45581 wxString const &arg3_defvalue = wxPyEmptyString ;
45582 wxString *arg3 = (wxString *) &arg3_defvalue ;
45583 wxString const &arg4_defvalue = wxPyEmptyString ;
45584 wxString *arg4 = (wxString *) &arg4_defvalue ;
45585 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45586 wxMenu *arg6 = (wxMenu *) NULL ;
45587 wxMenuItem *result = 0 ;
45588 void *argp1 = 0 ;
45589 int res1 = 0 ;
45590 int val2 ;
45591 int ecode2 = 0 ;
45592 bool temp3 = false ;
45593 bool temp4 = false ;
45594 int val5 ;
45595 int ecode5 = 0 ;
45596 void *argp6 = 0 ;
45597 int res6 = 0 ;
45598 PyObject * obj0 = 0 ;
45599 PyObject * obj1 = 0 ;
45600 PyObject * obj2 = 0 ;
45601 PyObject * obj3 = 0 ;
45602 PyObject * obj4 = 0 ;
45603 PyObject * obj5 = 0 ;
45604 char * kwnames[] = {
45605 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45606 };
45607
45608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45609 if (obj0) {
45610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45611 if (!SWIG_IsOK(res1)) {
45612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
45613 }
45614 arg1 = reinterpret_cast< wxMenu * >(argp1);
45615 }
45616 if (obj1) {
45617 ecode2 = SWIG_AsVal_int(obj1, &val2);
45618 if (!SWIG_IsOK(ecode2)) {
45619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45620 }
45621 arg2 = static_cast< int >(val2);
45622 }
45623 if (obj2) {
45624 {
45625 arg3 = wxString_in_helper(obj2);
45626 if (arg3 == NULL) SWIG_fail;
45627 temp3 = true;
45628 }
45629 }
45630 if (obj3) {
45631 {
45632 arg4 = wxString_in_helper(obj3);
45633 if (arg4 == NULL) SWIG_fail;
45634 temp4 = true;
45635 }
45636 }
45637 if (obj4) {
45638 ecode5 = SWIG_AsVal_int(obj4, &val5);
45639 if (!SWIG_IsOK(ecode5)) {
45640 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
45641 }
45642 arg5 = static_cast< wxItemKind >(val5);
45643 }
45644 if (obj5) {
45645 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
45646 if (!SWIG_IsOK(res6)) {
45647 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
45648 }
45649 arg6 = reinterpret_cast< wxMenu * >(argp6);
45650 }
45651 {
45652 PyThreadState* __tstate = wxPyBeginAllowThreads();
45653 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
45654 wxPyEndAllowThreads(__tstate);
45655 if (PyErr_Occurred()) SWIG_fail;
45656 }
45657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
45658 {
45659 if (temp3)
45660 delete arg3;
45661 }
45662 {
45663 if (temp4)
45664 delete arg4;
45665 }
45666 return resultobj;
45667 fail:
45668 {
45669 if (temp3)
45670 delete arg3;
45671 }
45672 {
45673 if (temp4)
45674 delete arg4;
45675 }
45676 return NULL;
45677 }
45678
45679
45680 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45681 PyObject *resultobj = 0;
45682 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45683 void *argp1 = 0 ;
45684 int res1 = 0 ;
45685 PyObject *swig_obj[1] ;
45686
45687 if (!args) SWIG_fail;
45688 swig_obj[0] = args;
45689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
45690 if (!SWIG_IsOK(res1)) {
45691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45692 }
45693 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45694 {
45695 PyThreadState* __tstate = wxPyBeginAllowThreads();
45696 delete arg1;
45697
45698 wxPyEndAllowThreads(__tstate);
45699 if (PyErr_Occurred()) SWIG_fail;
45700 }
45701 resultobj = SWIG_Py_Void();
45702 return resultobj;
45703 fail:
45704 return NULL;
45705 }
45706
45707
45708 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45709 PyObject *resultobj = 0;
45710 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45711 wxMenu *result = 0 ;
45712 void *argp1 = 0 ;
45713 int res1 = 0 ;
45714 PyObject *swig_obj[1] ;
45715
45716 if (!args) SWIG_fail;
45717 swig_obj[0] = args;
45718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45719 if (!SWIG_IsOK(res1)) {
45720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45721 }
45722 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45723 {
45724 PyThreadState* __tstate = wxPyBeginAllowThreads();
45725 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
45726 wxPyEndAllowThreads(__tstate);
45727 if (PyErr_Occurred()) SWIG_fail;
45728 }
45729 {
45730 resultobj = wxPyMake_wxObject(result, 0);
45731 }
45732 return resultobj;
45733 fail:
45734 return NULL;
45735 }
45736
45737
45738 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45739 PyObject *resultobj = 0;
45740 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45741 wxMenu *arg2 = (wxMenu *) 0 ;
45742 void *argp1 = 0 ;
45743 int res1 = 0 ;
45744 void *argp2 = 0 ;
45745 int res2 = 0 ;
45746 PyObject * obj0 = 0 ;
45747 PyObject * obj1 = 0 ;
45748 char * kwnames[] = {
45749 (char *) "self",(char *) "menu", NULL
45750 };
45751
45752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45754 if (!SWIG_IsOK(res1)) {
45755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45756 }
45757 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45758 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45759 if (!SWIG_IsOK(res2)) {
45760 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
45761 }
45762 arg2 = reinterpret_cast< wxMenu * >(argp2);
45763 {
45764 PyThreadState* __tstate = wxPyBeginAllowThreads();
45765 (arg1)->SetMenu(arg2);
45766 wxPyEndAllowThreads(__tstate);
45767 if (PyErr_Occurred()) SWIG_fail;
45768 }
45769 resultobj = SWIG_Py_Void();
45770 return resultobj;
45771 fail:
45772 return NULL;
45773 }
45774
45775
45776 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45777 PyObject *resultobj = 0;
45778 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45779 int arg2 ;
45780 void *argp1 = 0 ;
45781 int res1 = 0 ;
45782 int val2 ;
45783 int ecode2 = 0 ;
45784 PyObject * obj0 = 0 ;
45785 PyObject * obj1 = 0 ;
45786 char * kwnames[] = {
45787 (char *) "self",(char *) "id", NULL
45788 };
45789
45790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
45791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45792 if (!SWIG_IsOK(res1)) {
45793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45794 }
45795 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45796 ecode2 = SWIG_AsVal_int(obj1, &val2);
45797 if (!SWIG_IsOK(ecode2)) {
45798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
45799 }
45800 arg2 = static_cast< int >(val2);
45801 {
45802 PyThreadState* __tstate = wxPyBeginAllowThreads();
45803 (arg1)->SetId(arg2);
45804 wxPyEndAllowThreads(__tstate);
45805 if (PyErr_Occurred()) SWIG_fail;
45806 }
45807 resultobj = SWIG_Py_Void();
45808 return resultobj;
45809 fail:
45810 return NULL;
45811 }
45812
45813
45814 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45815 PyObject *resultobj = 0;
45816 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45817 int result;
45818 void *argp1 = 0 ;
45819 int res1 = 0 ;
45820 PyObject *swig_obj[1] ;
45821
45822 if (!args) SWIG_fail;
45823 swig_obj[0] = args;
45824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45825 if (!SWIG_IsOK(res1)) {
45826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45827 }
45828 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45829 {
45830 PyThreadState* __tstate = wxPyBeginAllowThreads();
45831 result = (int)((wxMenuItem const *)arg1)->GetId();
45832 wxPyEndAllowThreads(__tstate);
45833 if (PyErr_Occurred()) SWIG_fail;
45834 }
45835 resultobj = SWIG_From_int(static_cast< int >(result));
45836 return resultobj;
45837 fail:
45838 return NULL;
45839 }
45840
45841
45842 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45843 PyObject *resultobj = 0;
45844 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45845 bool result;
45846 void *argp1 = 0 ;
45847 int res1 = 0 ;
45848 PyObject *swig_obj[1] ;
45849
45850 if (!args) SWIG_fail;
45851 swig_obj[0] = args;
45852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45853 if (!SWIG_IsOK(res1)) {
45854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45855 }
45856 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45857 {
45858 PyThreadState* __tstate = wxPyBeginAllowThreads();
45859 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
45860 wxPyEndAllowThreads(__tstate);
45861 if (PyErr_Occurred()) SWIG_fail;
45862 }
45863 {
45864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45865 }
45866 return resultobj;
45867 fail:
45868 return NULL;
45869 }
45870
45871
45872 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45873 PyObject *resultobj = 0;
45874 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45875 wxString *arg2 = 0 ;
45876 void *argp1 = 0 ;
45877 int res1 = 0 ;
45878 bool temp2 = false ;
45879 PyObject * obj0 = 0 ;
45880 PyObject * obj1 = 0 ;
45881 char * kwnames[] = {
45882 (char *) "self",(char *) "str", NULL
45883 };
45884
45885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
45886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45887 if (!SWIG_IsOK(res1)) {
45888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45889 }
45890 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45891 {
45892 arg2 = wxString_in_helper(obj1);
45893 if (arg2 == NULL) SWIG_fail;
45894 temp2 = true;
45895 }
45896 {
45897 PyThreadState* __tstate = wxPyBeginAllowThreads();
45898 (arg1)->SetText((wxString const &)*arg2);
45899 wxPyEndAllowThreads(__tstate);
45900 if (PyErr_Occurred()) SWIG_fail;
45901 }
45902 resultobj = SWIG_Py_Void();
45903 {
45904 if (temp2)
45905 delete arg2;
45906 }
45907 return resultobj;
45908 fail:
45909 {
45910 if (temp2)
45911 delete arg2;
45912 }
45913 return NULL;
45914 }
45915
45916
45917 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45918 PyObject *resultobj = 0;
45919 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45920 wxString result;
45921 void *argp1 = 0 ;
45922 int res1 = 0 ;
45923 PyObject *swig_obj[1] ;
45924
45925 if (!args) SWIG_fail;
45926 swig_obj[0] = args;
45927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45928 if (!SWIG_IsOK(res1)) {
45929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45930 }
45931 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45932 {
45933 PyThreadState* __tstate = wxPyBeginAllowThreads();
45934 result = ((wxMenuItem const *)arg1)->GetLabel();
45935 wxPyEndAllowThreads(__tstate);
45936 if (PyErr_Occurred()) SWIG_fail;
45937 }
45938 {
45939 #if wxUSE_UNICODE
45940 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45941 #else
45942 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45943 #endif
45944 }
45945 return resultobj;
45946 fail:
45947 return NULL;
45948 }
45949
45950
45951 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45952 PyObject *resultobj = 0;
45953 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45954 wxString *result = 0 ;
45955 void *argp1 = 0 ;
45956 int res1 = 0 ;
45957 PyObject *swig_obj[1] ;
45958
45959 if (!args) SWIG_fail;
45960 swig_obj[0] = args;
45961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45962 if (!SWIG_IsOK(res1)) {
45963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45964 }
45965 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45966 {
45967 PyThreadState* __tstate = wxPyBeginAllowThreads();
45968 {
45969 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
45970 result = (wxString *) &_result_ref;
45971 }
45972 wxPyEndAllowThreads(__tstate);
45973 if (PyErr_Occurred()) SWIG_fail;
45974 }
45975 {
45976 #if wxUSE_UNICODE
45977 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
45978 #else
45979 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
45980 #endif
45981 }
45982 return resultobj;
45983 fail:
45984 return NULL;
45985 }
45986
45987
45988 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45989 PyObject *resultobj = 0;
45990 wxString *arg1 = 0 ;
45991 wxString result;
45992 bool temp1 = false ;
45993 PyObject * obj0 = 0 ;
45994 char * kwnames[] = {
45995 (char *) "text", NULL
45996 };
45997
45998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
45999 {
46000 arg1 = wxString_in_helper(obj0);
46001 if (arg1 == NULL) SWIG_fail;
46002 temp1 = true;
46003 }
46004 {
46005 PyThreadState* __tstate = wxPyBeginAllowThreads();
46006 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46007 wxPyEndAllowThreads(__tstate);
46008 if (PyErr_Occurred()) SWIG_fail;
46009 }
46010 {
46011 #if wxUSE_UNICODE
46012 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46013 #else
46014 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46015 #endif
46016 }
46017 {
46018 if (temp1)
46019 delete arg1;
46020 }
46021 return resultobj;
46022 fail:
46023 {
46024 if (temp1)
46025 delete arg1;
46026 }
46027 return NULL;
46028 }
46029
46030
46031 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46032 PyObject *resultobj = 0;
46033 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46034 wxItemKind result;
46035 void *argp1 = 0 ;
46036 int res1 = 0 ;
46037 PyObject *swig_obj[1] ;
46038
46039 if (!args) SWIG_fail;
46040 swig_obj[0] = args;
46041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46042 if (!SWIG_IsOK(res1)) {
46043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46044 }
46045 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46046 {
46047 PyThreadState* __tstate = wxPyBeginAllowThreads();
46048 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46049 wxPyEndAllowThreads(__tstate);
46050 if (PyErr_Occurred()) SWIG_fail;
46051 }
46052 resultobj = SWIG_From_int(static_cast< int >(result));
46053 return resultobj;
46054 fail:
46055 return NULL;
46056 }
46057
46058
46059 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46060 PyObject *resultobj = 0;
46061 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46062 wxItemKind arg2 ;
46063 void *argp1 = 0 ;
46064 int res1 = 0 ;
46065 int val2 ;
46066 int ecode2 = 0 ;
46067 PyObject * obj0 = 0 ;
46068 PyObject * obj1 = 0 ;
46069 char * kwnames[] = {
46070 (char *) "self",(char *) "kind", NULL
46071 };
46072
46073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46075 if (!SWIG_IsOK(res1)) {
46076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46077 }
46078 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46079 ecode2 = SWIG_AsVal_int(obj1, &val2);
46080 if (!SWIG_IsOK(ecode2)) {
46081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46082 }
46083 arg2 = static_cast< wxItemKind >(val2);
46084 {
46085 PyThreadState* __tstate = wxPyBeginAllowThreads();
46086 (arg1)->SetKind(arg2);
46087 wxPyEndAllowThreads(__tstate);
46088 if (PyErr_Occurred()) SWIG_fail;
46089 }
46090 resultobj = SWIG_Py_Void();
46091 return resultobj;
46092 fail:
46093 return NULL;
46094 }
46095
46096
46097 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46098 PyObject *resultobj = 0;
46099 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46100 bool arg2 ;
46101 void *argp1 = 0 ;
46102 int res1 = 0 ;
46103 bool val2 ;
46104 int ecode2 = 0 ;
46105 PyObject * obj0 = 0 ;
46106 PyObject * obj1 = 0 ;
46107 char * kwnames[] = {
46108 (char *) "self",(char *) "checkable", NULL
46109 };
46110
46111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46113 if (!SWIG_IsOK(res1)) {
46114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46115 }
46116 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46117 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46118 if (!SWIG_IsOK(ecode2)) {
46119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46120 }
46121 arg2 = static_cast< bool >(val2);
46122 {
46123 PyThreadState* __tstate = wxPyBeginAllowThreads();
46124 (arg1)->SetCheckable(arg2);
46125 wxPyEndAllowThreads(__tstate);
46126 if (PyErr_Occurred()) SWIG_fail;
46127 }
46128 resultobj = SWIG_Py_Void();
46129 return resultobj;
46130 fail:
46131 return NULL;
46132 }
46133
46134
46135 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46136 PyObject *resultobj = 0;
46137 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46138 bool result;
46139 void *argp1 = 0 ;
46140 int res1 = 0 ;
46141 PyObject *swig_obj[1] ;
46142
46143 if (!args) SWIG_fail;
46144 swig_obj[0] = args;
46145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46146 if (!SWIG_IsOK(res1)) {
46147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46148 }
46149 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46150 {
46151 PyThreadState* __tstate = wxPyBeginAllowThreads();
46152 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46153 wxPyEndAllowThreads(__tstate);
46154 if (PyErr_Occurred()) SWIG_fail;
46155 }
46156 {
46157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46158 }
46159 return resultobj;
46160 fail:
46161 return NULL;
46162 }
46163
46164
46165 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46166 PyObject *resultobj = 0;
46167 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46168 bool result;
46169 void *argp1 = 0 ;
46170 int res1 = 0 ;
46171 PyObject *swig_obj[1] ;
46172
46173 if (!args) SWIG_fail;
46174 swig_obj[0] = args;
46175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46176 if (!SWIG_IsOK(res1)) {
46177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46178 }
46179 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46180 {
46181 PyThreadState* __tstate = wxPyBeginAllowThreads();
46182 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46183 wxPyEndAllowThreads(__tstate);
46184 if (PyErr_Occurred()) SWIG_fail;
46185 }
46186 {
46187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46188 }
46189 return resultobj;
46190 fail:
46191 return NULL;
46192 }
46193
46194
46195 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46196 PyObject *resultobj = 0;
46197 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46198 wxMenu *arg2 = (wxMenu *) 0 ;
46199 void *argp1 = 0 ;
46200 int res1 = 0 ;
46201 void *argp2 = 0 ;
46202 int res2 = 0 ;
46203 PyObject * obj0 = 0 ;
46204 PyObject * obj1 = 0 ;
46205 char * kwnames[] = {
46206 (char *) "self",(char *) "menu", NULL
46207 };
46208
46209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46211 if (!SWIG_IsOK(res1)) {
46212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46213 }
46214 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46215 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46216 if (!SWIG_IsOK(res2)) {
46217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46218 }
46219 arg2 = reinterpret_cast< wxMenu * >(argp2);
46220 {
46221 PyThreadState* __tstate = wxPyBeginAllowThreads();
46222 (arg1)->SetSubMenu(arg2);
46223 wxPyEndAllowThreads(__tstate);
46224 if (PyErr_Occurred()) SWIG_fail;
46225 }
46226 resultobj = SWIG_Py_Void();
46227 return resultobj;
46228 fail:
46229 return NULL;
46230 }
46231
46232
46233 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46234 PyObject *resultobj = 0;
46235 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46236 wxMenu *result = 0 ;
46237 void *argp1 = 0 ;
46238 int res1 = 0 ;
46239 PyObject *swig_obj[1] ;
46240
46241 if (!args) SWIG_fail;
46242 swig_obj[0] = args;
46243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46244 if (!SWIG_IsOK(res1)) {
46245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46246 }
46247 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46248 {
46249 PyThreadState* __tstate = wxPyBeginAllowThreads();
46250 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46251 wxPyEndAllowThreads(__tstate);
46252 if (PyErr_Occurred()) SWIG_fail;
46253 }
46254 {
46255 resultobj = wxPyMake_wxObject(result, 0);
46256 }
46257 return resultobj;
46258 fail:
46259 return NULL;
46260 }
46261
46262
46263 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46264 PyObject *resultobj = 0;
46265 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46266 bool arg2 = (bool) true ;
46267 void *argp1 = 0 ;
46268 int res1 = 0 ;
46269 bool val2 ;
46270 int ecode2 = 0 ;
46271 PyObject * obj0 = 0 ;
46272 PyObject * obj1 = 0 ;
46273 char * kwnames[] = {
46274 (char *) "self",(char *) "enable", NULL
46275 };
46276
46277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46279 if (!SWIG_IsOK(res1)) {
46280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46281 }
46282 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46283 if (obj1) {
46284 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46285 if (!SWIG_IsOK(ecode2)) {
46286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46287 }
46288 arg2 = static_cast< bool >(val2);
46289 }
46290 {
46291 PyThreadState* __tstate = wxPyBeginAllowThreads();
46292 (arg1)->Enable(arg2);
46293 wxPyEndAllowThreads(__tstate);
46294 if (PyErr_Occurred()) SWIG_fail;
46295 }
46296 resultobj = SWIG_Py_Void();
46297 return resultobj;
46298 fail:
46299 return NULL;
46300 }
46301
46302
46303 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46304 PyObject *resultobj = 0;
46305 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46306 bool result;
46307 void *argp1 = 0 ;
46308 int res1 = 0 ;
46309 PyObject *swig_obj[1] ;
46310
46311 if (!args) SWIG_fail;
46312 swig_obj[0] = args;
46313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46314 if (!SWIG_IsOK(res1)) {
46315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46316 }
46317 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46318 {
46319 PyThreadState* __tstate = wxPyBeginAllowThreads();
46320 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46321 wxPyEndAllowThreads(__tstate);
46322 if (PyErr_Occurred()) SWIG_fail;
46323 }
46324 {
46325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46326 }
46327 return resultobj;
46328 fail:
46329 return NULL;
46330 }
46331
46332
46333 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46334 PyObject *resultobj = 0;
46335 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46336 bool arg2 = (bool) true ;
46337 void *argp1 = 0 ;
46338 int res1 = 0 ;
46339 bool val2 ;
46340 int ecode2 = 0 ;
46341 PyObject * obj0 = 0 ;
46342 PyObject * obj1 = 0 ;
46343 char * kwnames[] = {
46344 (char *) "self",(char *) "check", NULL
46345 };
46346
46347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46349 if (!SWIG_IsOK(res1)) {
46350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46351 }
46352 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46353 if (obj1) {
46354 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46355 if (!SWIG_IsOK(ecode2)) {
46356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46357 }
46358 arg2 = static_cast< bool >(val2);
46359 }
46360 {
46361 PyThreadState* __tstate = wxPyBeginAllowThreads();
46362 (arg1)->Check(arg2);
46363 wxPyEndAllowThreads(__tstate);
46364 if (PyErr_Occurred()) SWIG_fail;
46365 }
46366 resultobj = SWIG_Py_Void();
46367 return resultobj;
46368 fail:
46369 return NULL;
46370 }
46371
46372
46373 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46374 PyObject *resultobj = 0;
46375 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46376 bool result;
46377 void *argp1 = 0 ;
46378 int res1 = 0 ;
46379 PyObject *swig_obj[1] ;
46380
46381 if (!args) SWIG_fail;
46382 swig_obj[0] = args;
46383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46384 if (!SWIG_IsOK(res1)) {
46385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46386 }
46387 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46388 {
46389 PyThreadState* __tstate = wxPyBeginAllowThreads();
46390 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46391 wxPyEndAllowThreads(__tstate);
46392 if (PyErr_Occurred()) SWIG_fail;
46393 }
46394 {
46395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46396 }
46397 return resultobj;
46398 fail:
46399 return NULL;
46400 }
46401
46402
46403 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46404 PyObject *resultobj = 0;
46405 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46406 void *argp1 = 0 ;
46407 int res1 = 0 ;
46408 PyObject *swig_obj[1] ;
46409
46410 if (!args) SWIG_fail;
46411 swig_obj[0] = args;
46412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46413 if (!SWIG_IsOK(res1)) {
46414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46415 }
46416 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46417 {
46418 PyThreadState* __tstate = wxPyBeginAllowThreads();
46419 (arg1)->Toggle();
46420 wxPyEndAllowThreads(__tstate);
46421 if (PyErr_Occurred()) SWIG_fail;
46422 }
46423 resultobj = SWIG_Py_Void();
46424 return resultobj;
46425 fail:
46426 return NULL;
46427 }
46428
46429
46430 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46431 PyObject *resultobj = 0;
46432 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46433 wxString *arg2 = 0 ;
46434 void *argp1 = 0 ;
46435 int res1 = 0 ;
46436 bool temp2 = false ;
46437 PyObject * obj0 = 0 ;
46438 PyObject * obj1 = 0 ;
46439 char * kwnames[] = {
46440 (char *) "self",(char *) "str", NULL
46441 };
46442
46443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46445 if (!SWIG_IsOK(res1)) {
46446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46447 }
46448 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46449 {
46450 arg2 = wxString_in_helper(obj1);
46451 if (arg2 == NULL) SWIG_fail;
46452 temp2 = true;
46453 }
46454 {
46455 PyThreadState* __tstate = wxPyBeginAllowThreads();
46456 (arg1)->SetHelp((wxString const &)*arg2);
46457 wxPyEndAllowThreads(__tstate);
46458 if (PyErr_Occurred()) SWIG_fail;
46459 }
46460 resultobj = SWIG_Py_Void();
46461 {
46462 if (temp2)
46463 delete arg2;
46464 }
46465 return resultobj;
46466 fail:
46467 {
46468 if (temp2)
46469 delete arg2;
46470 }
46471 return NULL;
46472 }
46473
46474
46475 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46476 PyObject *resultobj = 0;
46477 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46478 wxString *result = 0 ;
46479 void *argp1 = 0 ;
46480 int res1 = 0 ;
46481 PyObject *swig_obj[1] ;
46482
46483 if (!args) SWIG_fail;
46484 swig_obj[0] = args;
46485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46486 if (!SWIG_IsOK(res1)) {
46487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46488 }
46489 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46490 {
46491 PyThreadState* __tstate = wxPyBeginAllowThreads();
46492 {
46493 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46494 result = (wxString *) &_result_ref;
46495 }
46496 wxPyEndAllowThreads(__tstate);
46497 if (PyErr_Occurred()) SWIG_fail;
46498 }
46499 {
46500 #if wxUSE_UNICODE
46501 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46502 #else
46503 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46504 #endif
46505 }
46506 return resultobj;
46507 fail:
46508 return NULL;
46509 }
46510
46511
46512 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46513 PyObject *resultobj = 0;
46514 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46515 wxAcceleratorEntry *result = 0 ;
46516 void *argp1 = 0 ;
46517 int res1 = 0 ;
46518 PyObject *swig_obj[1] ;
46519
46520 if (!args) SWIG_fail;
46521 swig_obj[0] = args;
46522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46523 if (!SWIG_IsOK(res1)) {
46524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46525 }
46526 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46527 {
46528 PyThreadState* __tstate = wxPyBeginAllowThreads();
46529 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46530 wxPyEndAllowThreads(__tstate);
46531 if (PyErr_Occurred()) SWIG_fail;
46532 }
46533 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46534 return resultobj;
46535 fail:
46536 return NULL;
46537 }
46538
46539
46540 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46541 PyObject *resultobj = 0;
46542 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46543 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46544 void *argp1 = 0 ;
46545 int res1 = 0 ;
46546 void *argp2 = 0 ;
46547 int res2 = 0 ;
46548 PyObject * obj0 = 0 ;
46549 PyObject * obj1 = 0 ;
46550 char * kwnames[] = {
46551 (char *) "self",(char *) "accel", NULL
46552 };
46553
46554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46556 if (!SWIG_IsOK(res1)) {
46557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46558 }
46559 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46560 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46561 if (!SWIG_IsOK(res2)) {
46562 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46563 }
46564 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46565 {
46566 PyThreadState* __tstate = wxPyBeginAllowThreads();
46567 (arg1)->SetAccel(arg2);
46568 wxPyEndAllowThreads(__tstate);
46569 if (PyErr_Occurred()) SWIG_fail;
46570 }
46571 resultobj = SWIG_Py_Void();
46572 return resultobj;
46573 fail:
46574 return NULL;
46575 }
46576
46577
46578 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46579 PyObject *resultobj = 0;
46580 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46581 wxBitmap *arg2 = 0 ;
46582 void *argp1 = 0 ;
46583 int res1 = 0 ;
46584 void *argp2 = 0 ;
46585 int res2 = 0 ;
46586 PyObject * obj0 = 0 ;
46587 PyObject * obj1 = 0 ;
46588 char * kwnames[] = {
46589 (char *) "self",(char *) "bitmap", NULL
46590 };
46591
46592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46594 if (!SWIG_IsOK(res1)) {
46595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46596 }
46597 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46598 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46599 if (!SWIG_IsOK(res2)) {
46600 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46601 }
46602 if (!argp2) {
46603 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46604 }
46605 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46606 {
46607 PyThreadState* __tstate = wxPyBeginAllowThreads();
46608 (arg1)->SetBitmap((wxBitmap const &)*arg2);
46609 wxPyEndAllowThreads(__tstate);
46610 if (PyErr_Occurred()) SWIG_fail;
46611 }
46612 resultobj = SWIG_Py_Void();
46613 return resultobj;
46614 fail:
46615 return NULL;
46616 }
46617
46618
46619 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46620 PyObject *resultobj = 0;
46621 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46622 wxBitmap *result = 0 ;
46623 void *argp1 = 0 ;
46624 int res1 = 0 ;
46625 PyObject *swig_obj[1] ;
46626
46627 if (!args) SWIG_fail;
46628 swig_obj[0] = args;
46629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46630 if (!SWIG_IsOK(res1)) {
46631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46632 }
46633 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46634 {
46635 PyThreadState* __tstate = wxPyBeginAllowThreads();
46636 {
46637 wxBitmap const &_result_ref = (arg1)->GetBitmap();
46638 result = (wxBitmap *) &_result_ref;
46639 }
46640 wxPyEndAllowThreads(__tstate);
46641 if (PyErr_Occurred()) SWIG_fail;
46642 }
46643 {
46644 wxBitmap* resultptr = new wxBitmap(*result);
46645 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46646 }
46647 return resultobj;
46648 fail:
46649 return NULL;
46650 }
46651
46652
46653 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46654 PyObject *resultobj = 0;
46655 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46656 wxFont *arg2 = 0 ;
46657 void *argp1 = 0 ;
46658 int res1 = 0 ;
46659 void *argp2 = 0 ;
46660 int res2 = 0 ;
46661 PyObject * obj0 = 0 ;
46662 PyObject * obj1 = 0 ;
46663 char * kwnames[] = {
46664 (char *) "self",(char *) "font", NULL
46665 };
46666
46667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
46668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46669 if (!SWIG_IsOK(res1)) {
46670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46671 }
46672 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46673 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
46674 if (!SWIG_IsOK(res2)) {
46675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46676 }
46677 if (!argp2) {
46678 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46679 }
46680 arg2 = reinterpret_cast< wxFont * >(argp2);
46681 {
46682 PyThreadState* __tstate = wxPyBeginAllowThreads();
46683 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
46684 wxPyEndAllowThreads(__tstate);
46685 if (PyErr_Occurred()) SWIG_fail;
46686 }
46687 resultobj = SWIG_Py_Void();
46688 return resultobj;
46689 fail:
46690 return NULL;
46691 }
46692
46693
46694 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46695 PyObject *resultobj = 0;
46696 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46697 wxFont result;
46698 void *argp1 = 0 ;
46699 int res1 = 0 ;
46700 PyObject *swig_obj[1] ;
46701
46702 if (!args) SWIG_fail;
46703 swig_obj[0] = args;
46704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46705 if (!SWIG_IsOK(res1)) {
46706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46707 }
46708 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46709 {
46710 PyThreadState* __tstate = wxPyBeginAllowThreads();
46711 result = wxMenuItem_GetFont(arg1);
46712 wxPyEndAllowThreads(__tstate);
46713 if (PyErr_Occurred()) SWIG_fail;
46714 }
46715 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
46716 return resultobj;
46717 fail:
46718 return NULL;
46719 }
46720
46721
46722 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46723 PyObject *resultobj = 0;
46724 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46725 wxColour *arg2 = 0 ;
46726 void *argp1 = 0 ;
46727 int res1 = 0 ;
46728 wxColour temp2 ;
46729 PyObject * obj0 = 0 ;
46730 PyObject * obj1 = 0 ;
46731 char * kwnames[] = {
46732 (char *) "self",(char *) "colText", NULL
46733 };
46734
46735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
46736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46737 if (!SWIG_IsOK(res1)) {
46738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46739 }
46740 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46741 {
46742 arg2 = &temp2;
46743 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46744 }
46745 {
46746 PyThreadState* __tstate = wxPyBeginAllowThreads();
46747 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
46748 wxPyEndAllowThreads(__tstate);
46749 if (PyErr_Occurred()) SWIG_fail;
46750 }
46751 resultobj = SWIG_Py_Void();
46752 return resultobj;
46753 fail:
46754 return NULL;
46755 }
46756
46757
46758 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46759 PyObject *resultobj = 0;
46760 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46761 wxColour result;
46762 void *argp1 = 0 ;
46763 int res1 = 0 ;
46764 PyObject *swig_obj[1] ;
46765
46766 if (!args) SWIG_fail;
46767 swig_obj[0] = args;
46768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46769 if (!SWIG_IsOK(res1)) {
46770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46771 }
46772 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46773 {
46774 PyThreadState* __tstate = wxPyBeginAllowThreads();
46775 result = wxMenuItem_GetTextColour(arg1);
46776 wxPyEndAllowThreads(__tstate);
46777 if (PyErr_Occurred()) SWIG_fail;
46778 }
46779 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46780 return resultobj;
46781 fail:
46782 return NULL;
46783 }
46784
46785
46786 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46787 PyObject *resultobj = 0;
46788 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46789 wxColour *arg2 = 0 ;
46790 void *argp1 = 0 ;
46791 int res1 = 0 ;
46792 wxColour temp2 ;
46793 PyObject * obj0 = 0 ;
46794 PyObject * obj1 = 0 ;
46795 char * kwnames[] = {
46796 (char *) "self",(char *) "colBack", NULL
46797 };
46798
46799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
46800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46801 if (!SWIG_IsOK(res1)) {
46802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46803 }
46804 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46805 {
46806 arg2 = &temp2;
46807 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46808 }
46809 {
46810 PyThreadState* __tstate = wxPyBeginAllowThreads();
46811 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
46812 wxPyEndAllowThreads(__tstate);
46813 if (PyErr_Occurred()) SWIG_fail;
46814 }
46815 resultobj = SWIG_Py_Void();
46816 return resultobj;
46817 fail:
46818 return NULL;
46819 }
46820
46821
46822 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46823 PyObject *resultobj = 0;
46824 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46825 wxColour result;
46826 void *argp1 = 0 ;
46827 int res1 = 0 ;
46828 PyObject *swig_obj[1] ;
46829
46830 if (!args) SWIG_fail;
46831 swig_obj[0] = args;
46832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46833 if (!SWIG_IsOK(res1)) {
46834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46835 }
46836 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46837 {
46838 PyThreadState* __tstate = wxPyBeginAllowThreads();
46839 result = wxMenuItem_GetBackgroundColour(arg1);
46840 wxPyEndAllowThreads(__tstate);
46841 if (PyErr_Occurred()) SWIG_fail;
46842 }
46843 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46844 return resultobj;
46845 fail:
46846 return NULL;
46847 }
46848
46849
46850 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46851 PyObject *resultobj = 0;
46852 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46853 wxBitmap *arg2 = 0 ;
46854 wxBitmap const &arg3_defvalue = wxNullBitmap ;
46855 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
46856 void *argp1 = 0 ;
46857 int res1 = 0 ;
46858 void *argp2 = 0 ;
46859 int res2 = 0 ;
46860 void *argp3 = 0 ;
46861 int res3 = 0 ;
46862 PyObject * obj0 = 0 ;
46863 PyObject * obj1 = 0 ;
46864 PyObject * obj2 = 0 ;
46865 char * kwnames[] = {
46866 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
46867 };
46868
46869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46871 if (!SWIG_IsOK(res1)) {
46872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46873 }
46874 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46875 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46876 if (!SWIG_IsOK(res2)) {
46877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46878 }
46879 if (!argp2) {
46880 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46881 }
46882 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46883 if (obj2) {
46884 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
46885 if (!SWIG_IsOK(res3)) {
46886 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46887 }
46888 if (!argp3) {
46889 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46890 }
46891 arg3 = reinterpret_cast< wxBitmap * >(argp3);
46892 }
46893 {
46894 PyThreadState* __tstate = wxPyBeginAllowThreads();
46895 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
46896 wxPyEndAllowThreads(__tstate);
46897 if (PyErr_Occurred()) SWIG_fail;
46898 }
46899 resultobj = SWIG_Py_Void();
46900 return resultobj;
46901 fail:
46902 return NULL;
46903 }
46904
46905
46906 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46907 PyObject *resultobj = 0;
46908 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46909 wxBitmap *arg2 = 0 ;
46910 void *argp1 = 0 ;
46911 int res1 = 0 ;
46912 void *argp2 = 0 ;
46913 int res2 = 0 ;
46914 PyObject * obj0 = 0 ;
46915 PyObject * obj1 = 0 ;
46916 char * kwnames[] = {
46917 (char *) "self",(char *) "bmpDisabled", NULL
46918 };
46919
46920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46922 if (!SWIG_IsOK(res1)) {
46923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46924 }
46925 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46926 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46927 if (!SWIG_IsOK(res2)) {
46928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46929 }
46930 if (!argp2) {
46931 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46932 }
46933 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46934 {
46935 PyThreadState* __tstate = wxPyBeginAllowThreads();
46936 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
46937 wxPyEndAllowThreads(__tstate);
46938 if (PyErr_Occurred()) SWIG_fail;
46939 }
46940 resultobj = SWIG_Py_Void();
46941 return resultobj;
46942 fail:
46943 return NULL;
46944 }
46945
46946
46947 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46948 PyObject *resultobj = 0;
46949 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46950 wxBitmap *result = 0 ;
46951 void *argp1 = 0 ;
46952 int res1 = 0 ;
46953 PyObject *swig_obj[1] ;
46954
46955 if (!args) SWIG_fail;
46956 swig_obj[0] = args;
46957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46958 if (!SWIG_IsOK(res1)) {
46959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46960 }
46961 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46962 {
46963 PyThreadState* __tstate = wxPyBeginAllowThreads();
46964 {
46965 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
46966 result = (wxBitmap *) &_result_ref;
46967 }
46968 wxPyEndAllowThreads(__tstate);
46969 if (PyErr_Occurred()) SWIG_fail;
46970 }
46971 {
46972 wxBitmap* resultptr = new wxBitmap(*result);
46973 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46974 }
46975 return resultobj;
46976 fail:
46977 return NULL;
46978 }
46979
46980
46981 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46982 PyObject *resultobj = 0;
46983 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46984 int arg2 ;
46985 void *argp1 = 0 ;
46986 int res1 = 0 ;
46987 int val2 ;
46988 int ecode2 = 0 ;
46989 PyObject * obj0 = 0 ;
46990 PyObject * obj1 = 0 ;
46991 char * kwnames[] = {
46992 (char *) "self",(char *) "nWidth", NULL
46993 };
46994
46995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
46996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46997 if (!SWIG_IsOK(res1)) {
46998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46999 }
47000 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47001 ecode2 = SWIG_AsVal_int(obj1, &val2);
47002 if (!SWIG_IsOK(ecode2)) {
47003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47004 }
47005 arg2 = static_cast< int >(val2);
47006 {
47007 PyThreadState* __tstate = wxPyBeginAllowThreads();
47008 wxMenuItem_SetMarginWidth(arg1,arg2);
47009 wxPyEndAllowThreads(__tstate);
47010 if (PyErr_Occurred()) SWIG_fail;
47011 }
47012 resultobj = SWIG_Py_Void();
47013 return resultobj;
47014 fail:
47015 return NULL;
47016 }
47017
47018
47019 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47020 PyObject *resultobj = 0;
47021 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47022 int result;
47023 void *argp1 = 0 ;
47024 int res1 = 0 ;
47025 PyObject *swig_obj[1] ;
47026
47027 if (!args) SWIG_fail;
47028 swig_obj[0] = args;
47029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47030 if (!SWIG_IsOK(res1)) {
47031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47032 }
47033 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47034 {
47035 PyThreadState* __tstate = wxPyBeginAllowThreads();
47036 result = (int)wxMenuItem_GetMarginWidth(arg1);
47037 wxPyEndAllowThreads(__tstate);
47038 if (PyErr_Occurred()) SWIG_fail;
47039 }
47040 resultobj = SWIG_From_int(static_cast< int >(result));
47041 return resultobj;
47042 fail:
47043 return NULL;
47044 }
47045
47046
47047 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47048 PyObject *resultobj = 0;
47049 int result;
47050
47051 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47052 {
47053 PyThreadState* __tstate = wxPyBeginAllowThreads();
47054 result = (int)wxMenuItem_GetDefaultMarginWidth();
47055 wxPyEndAllowThreads(__tstate);
47056 if (PyErr_Occurred()) SWIG_fail;
47057 }
47058 resultobj = SWIG_From_int(static_cast< int >(result));
47059 return resultobj;
47060 fail:
47061 return NULL;
47062 }
47063
47064
47065 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47066 PyObject *resultobj = 0;
47067 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47068 bool result;
47069 void *argp1 = 0 ;
47070 int res1 = 0 ;
47071 PyObject *swig_obj[1] ;
47072
47073 if (!args) SWIG_fail;
47074 swig_obj[0] = args;
47075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47076 if (!SWIG_IsOK(res1)) {
47077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47078 }
47079 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47080 {
47081 PyThreadState* __tstate = wxPyBeginAllowThreads();
47082 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
47083 wxPyEndAllowThreads(__tstate);
47084 if (PyErr_Occurred()) SWIG_fail;
47085 }
47086 {
47087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47088 }
47089 return resultobj;
47090 fail:
47091 return NULL;
47092 }
47093
47094
47095 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47096 PyObject *resultobj = 0;
47097 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47098 bool arg2 = (bool) true ;
47099 void *argp1 = 0 ;
47100 int res1 = 0 ;
47101 bool val2 ;
47102 int ecode2 = 0 ;
47103 PyObject * obj0 = 0 ;
47104 PyObject * obj1 = 0 ;
47105 char * kwnames[] = {
47106 (char *) "self",(char *) "ownerDrawn", NULL
47107 };
47108
47109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47111 if (!SWIG_IsOK(res1)) {
47112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47113 }
47114 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47115 if (obj1) {
47116 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47117 if (!SWIG_IsOK(ecode2)) {
47118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47119 }
47120 arg2 = static_cast< bool >(val2);
47121 }
47122 {
47123 PyThreadState* __tstate = wxPyBeginAllowThreads();
47124 wxMenuItem_SetOwnerDrawn(arg1,arg2);
47125 wxPyEndAllowThreads(__tstate);
47126 if (PyErr_Occurred()) SWIG_fail;
47127 }
47128 resultobj = SWIG_Py_Void();
47129 return resultobj;
47130 fail:
47131 return NULL;
47132 }
47133
47134
47135 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47136 PyObject *resultobj = 0;
47137 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47138 void *argp1 = 0 ;
47139 int res1 = 0 ;
47140 PyObject *swig_obj[1] ;
47141
47142 if (!args) SWIG_fail;
47143 swig_obj[0] = args;
47144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47145 if (!SWIG_IsOK(res1)) {
47146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47147 }
47148 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47149 {
47150 PyThreadState* __tstate = wxPyBeginAllowThreads();
47151 wxMenuItem_ResetOwnerDrawn(arg1);
47152 wxPyEndAllowThreads(__tstate);
47153 if (PyErr_Occurred()) SWIG_fail;
47154 }
47155 resultobj = SWIG_Py_Void();
47156 return resultobj;
47157 fail:
47158 return NULL;
47159 }
47160
47161
47162 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47163 PyObject *obj;
47164 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47165 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47166 return SWIG_Py_Void();
47167 }
47168
47169 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47170 return SWIG_Python_InitShadowInstance(args);
47171 }
47172
47173 SWIGINTERN int ControlNameStr_set(PyObject *) {
47174 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47175 return 1;
47176 }
47177
47178
47179 SWIGINTERN PyObject *ControlNameStr_get(void) {
47180 PyObject *pyobj = 0;
47181
47182 {
47183 #if wxUSE_UNICODE
47184 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47185 #else
47186 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47187 #endif
47188 }
47189 return pyobj;
47190 }
47191
47192
47193 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47194 PyObject *resultobj = 0;
47195 wxWindow *arg1 = (wxWindow *) 0 ;
47196 int arg2 = (int) -1 ;
47197 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47198 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47199 wxSize const &arg4_defvalue = wxDefaultSize ;
47200 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47201 long arg5 = (long) 0 ;
47202 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47203 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47204 wxString const &arg7_defvalue = wxPyControlNameStr ;
47205 wxString *arg7 = (wxString *) &arg7_defvalue ;
47206 wxControl *result = 0 ;
47207 void *argp1 = 0 ;
47208 int res1 = 0 ;
47209 int val2 ;
47210 int ecode2 = 0 ;
47211 wxPoint temp3 ;
47212 wxSize temp4 ;
47213 long val5 ;
47214 int ecode5 = 0 ;
47215 void *argp6 = 0 ;
47216 int res6 = 0 ;
47217 bool temp7 = false ;
47218 PyObject * obj0 = 0 ;
47219 PyObject * obj1 = 0 ;
47220 PyObject * obj2 = 0 ;
47221 PyObject * obj3 = 0 ;
47222 PyObject * obj4 = 0 ;
47223 PyObject * obj5 = 0 ;
47224 PyObject * obj6 = 0 ;
47225 char * kwnames[] = {
47226 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47227 };
47228
47229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47231 if (!SWIG_IsOK(res1)) {
47232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47233 }
47234 arg1 = reinterpret_cast< wxWindow * >(argp1);
47235 if (obj1) {
47236 ecode2 = SWIG_AsVal_int(obj1, &val2);
47237 if (!SWIG_IsOK(ecode2)) {
47238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47239 }
47240 arg2 = static_cast< int >(val2);
47241 }
47242 if (obj2) {
47243 {
47244 arg3 = &temp3;
47245 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47246 }
47247 }
47248 if (obj3) {
47249 {
47250 arg4 = &temp4;
47251 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47252 }
47253 }
47254 if (obj4) {
47255 ecode5 = SWIG_AsVal_long(obj4, &val5);
47256 if (!SWIG_IsOK(ecode5)) {
47257 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47258 }
47259 arg5 = static_cast< long >(val5);
47260 }
47261 if (obj5) {
47262 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47263 if (!SWIG_IsOK(res6)) {
47264 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47265 }
47266 if (!argp6) {
47267 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47268 }
47269 arg6 = reinterpret_cast< wxValidator * >(argp6);
47270 }
47271 if (obj6) {
47272 {
47273 arg7 = wxString_in_helper(obj6);
47274 if (arg7 == NULL) SWIG_fail;
47275 temp7 = true;
47276 }
47277 }
47278 {
47279 if (!wxPyCheckForApp()) SWIG_fail;
47280 PyThreadState* __tstate = wxPyBeginAllowThreads();
47281 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47282 wxPyEndAllowThreads(__tstate);
47283 if (PyErr_Occurred()) SWIG_fail;
47284 }
47285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47286 {
47287 if (temp7)
47288 delete arg7;
47289 }
47290 return resultobj;
47291 fail:
47292 {
47293 if (temp7)
47294 delete arg7;
47295 }
47296 return NULL;
47297 }
47298
47299
47300 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47301 PyObject *resultobj = 0;
47302 wxControl *result = 0 ;
47303
47304 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47305 {
47306 if (!wxPyCheckForApp()) SWIG_fail;
47307 PyThreadState* __tstate = wxPyBeginAllowThreads();
47308 result = (wxControl *)new wxControl();
47309 wxPyEndAllowThreads(__tstate);
47310 if (PyErr_Occurred()) SWIG_fail;
47311 }
47312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47313 return resultobj;
47314 fail:
47315 return NULL;
47316 }
47317
47318
47319 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47320 PyObject *resultobj = 0;
47321 wxControl *arg1 = (wxControl *) 0 ;
47322 wxWindow *arg2 = (wxWindow *) 0 ;
47323 int arg3 = (int) -1 ;
47324 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47325 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47326 wxSize const &arg5_defvalue = wxDefaultSize ;
47327 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47328 long arg6 = (long) 0 ;
47329 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47330 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47331 wxString const &arg8_defvalue = wxPyControlNameStr ;
47332 wxString *arg8 = (wxString *) &arg8_defvalue ;
47333 bool result;
47334 void *argp1 = 0 ;
47335 int res1 = 0 ;
47336 void *argp2 = 0 ;
47337 int res2 = 0 ;
47338 int val3 ;
47339 int ecode3 = 0 ;
47340 wxPoint temp4 ;
47341 wxSize temp5 ;
47342 long val6 ;
47343 int ecode6 = 0 ;
47344 void *argp7 = 0 ;
47345 int res7 = 0 ;
47346 bool temp8 = false ;
47347 PyObject * obj0 = 0 ;
47348 PyObject * obj1 = 0 ;
47349 PyObject * obj2 = 0 ;
47350 PyObject * obj3 = 0 ;
47351 PyObject * obj4 = 0 ;
47352 PyObject * obj5 = 0 ;
47353 PyObject * obj6 = 0 ;
47354 PyObject * obj7 = 0 ;
47355 char * kwnames[] = {
47356 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47357 };
47358
47359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47361 if (!SWIG_IsOK(res1)) {
47362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47363 }
47364 arg1 = reinterpret_cast< wxControl * >(argp1);
47365 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47366 if (!SWIG_IsOK(res2)) {
47367 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47368 }
47369 arg2 = reinterpret_cast< wxWindow * >(argp2);
47370 if (obj2) {
47371 ecode3 = SWIG_AsVal_int(obj2, &val3);
47372 if (!SWIG_IsOK(ecode3)) {
47373 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47374 }
47375 arg3 = static_cast< int >(val3);
47376 }
47377 if (obj3) {
47378 {
47379 arg4 = &temp4;
47380 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47381 }
47382 }
47383 if (obj4) {
47384 {
47385 arg5 = &temp5;
47386 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47387 }
47388 }
47389 if (obj5) {
47390 ecode6 = SWIG_AsVal_long(obj5, &val6);
47391 if (!SWIG_IsOK(ecode6)) {
47392 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47393 }
47394 arg6 = static_cast< long >(val6);
47395 }
47396 if (obj6) {
47397 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47398 if (!SWIG_IsOK(res7)) {
47399 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47400 }
47401 if (!argp7) {
47402 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47403 }
47404 arg7 = reinterpret_cast< wxValidator * >(argp7);
47405 }
47406 if (obj7) {
47407 {
47408 arg8 = wxString_in_helper(obj7);
47409 if (arg8 == NULL) SWIG_fail;
47410 temp8 = true;
47411 }
47412 }
47413 {
47414 PyThreadState* __tstate = wxPyBeginAllowThreads();
47415 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47416 wxPyEndAllowThreads(__tstate);
47417 if (PyErr_Occurred()) SWIG_fail;
47418 }
47419 {
47420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47421 }
47422 {
47423 if (temp8)
47424 delete arg8;
47425 }
47426 return resultobj;
47427 fail:
47428 {
47429 if (temp8)
47430 delete arg8;
47431 }
47432 return NULL;
47433 }
47434
47435
47436 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47437 PyObject *resultobj = 0;
47438 wxControl *arg1 = (wxControl *) 0 ;
47439 int result;
47440 void *argp1 = 0 ;
47441 int res1 = 0 ;
47442 PyObject *swig_obj[1] ;
47443
47444 if (!args) SWIG_fail;
47445 swig_obj[0] = args;
47446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47447 if (!SWIG_IsOK(res1)) {
47448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47449 }
47450 arg1 = reinterpret_cast< wxControl * >(argp1);
47451 {
47452 PyThreadState* __tstate = wxPyBeginAllowThreads();
47453 result = (int)((wxControl const *)arg1)->GetAlignment();
47454 wxPyEndAllowThreads(__tstate);
47455 if (PyErr_Occurred()) SWIG_fail;
47456 }
47457 resultobj = SWIG_From_int(static_cast< int >(result));
47458 return resultobj;
47459 fail:
47460 return NULL;
47461 }
47462
47463
47464 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47465 PyObject *resultobj = 0;
47466 wxControl *arg1 = (wxControl *) 0 ;
47467 wxString result;
47468 void *argp1 = 0 ;
47469 int res1 = 0 ;
47470 PyObject *swig_obj[1] ;
47471
47472 if (!args) SWIG_fail;
47473 swig_obj[0] = args;
47474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47475 if (!SWIG_IsOK(res1)) {
47476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47477 }
47478 arg1 = reinterpret_cast< wxControl * >(argp1);
47479 {
47480 PyThreadState* __tstate = wxPyBeginAllowThreads();
47481 result = ((wxControl const *)arg1)->GetLabelText();
47482 wxPyEndAllowThreads(__tstate);
47483 if (PyErr_Occurred()) SWIG_fail;
47484 }
47485 {
47486 #if wxUSE_UNICODE
47487 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47488 #else
47489 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47490 #endif
47491 }
47492 return resultobj;
47493 fail:
47494 return NULL;
47495 }
47496
47497
47498 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47499 PyObject *resultobj = 0;
47500 wxControl *arg1 = (wxControl *) 0 ;
47501 wxCommandEvent *arg2 = 0 ;
47502 void *argp1 = 0 ;
47503 int res1 = 0 ;
47504 void *argp2 = 0 ;
47505 int res2 = 0 ;
47506 PyObject * obj0 = 0 ;
47507 PyObject * obj1 = 0 ;
47508 char * kwnames[] = {
47509 (char *) "self",(char *) "event", NULL
47510 };
47511
47512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47514 if (!SWIG_IsOK(res1)) {
47515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47516 }
47517 arg1 = reinterpret_cast< wxControl * >(argp1);
47518 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47519 if (!SWIG_IsOK(res2)) {
47520 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47521 }
47522 if (!argp2) {
47523 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47524 }
47525 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47526 {
47527 PyThreadState* __tstate = wxPyBeginAllowThreads();
47528 (arg1)->Command(*arg2);
47529 wxPyEndAllowThreads(__tstate);
47530 if (PyErr_Occurred()) SWIG_fail;
47531 }
47532 resultobj = SWIG_Py_Void();
47533 return resultobj;
47534 fail:
47535 return NULL;
47536 }
47537
47538
47539 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47540 PyObject *resultobj = 0;
47541 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47542 SwigValueWrapper<wxVisualAttributes > result;
47543 int val1 ;
47544 int ecode1 = 0 ;
47545 PyObject * obj0 = 0 ;
47546 char * kwnames[] = {
47547 (char *) "variant", NULL
47548 };
47549
47550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47551 if (obj0) {
47552 ecode1 = SWIG_AsVal_int(obj0, &val1);
47553 if (!SWIG_IsOK(ecode1)) {
47554 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47555 }
47556 arg1 = static_cast< wxWindowVariant >(val1);
47557 }
47558 {
47559 if (!wxPyCheckForApp()) SWIG_fail;
47560 PyThreadState* __tstate = wxPyBeginAllowThreads();
47561 result = wxControl::GetClassDefaultAttributes(arg1);
47562 wxPyEndAllowThreads(__tstate);
47563 if (PyErr_Occurred()) SWIG_fail;
47564 }
47565 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47566 return resultobj;
47567 fail:
47568 return NULL;
47569 }
47570
47571
47572 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47573 PyObject *obj;
47574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47575 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47576 return SWIG_Py_Void();
47577 }
47578
47579 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47580 return SWIG_Python_InitShadowInstance(args);
47581 }
47582
47583 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47584 PyObject *resultobj = 0;
47585 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47586 wxString *arg2 = 0 ;
47587 PyObject *arg3 = (PyObject *) NULL ;
47588 int result;
47589 void *argp1 = 0 ;
47590 int res1 = 0 ;
47591 bool temp2 = false ;
47592 PyObject * obj0 = 0 ;
47593 PyObject * obj1 = 0 ;
47594 PyObject * obj2 = 0 ;
47595 char * kwnames[] = {
47596 (char *) "self",(char *) "item",(char *) "clientData", NULL
47597 };
47598
47599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47601 if (!SWIG_IsOK(res1)) {
47602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47603 }
47604 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47605 {
47606 arg2 = wxString_in_helper(obj1);
47607 if (arg2 == NULL) SWIG_fail;
47608 temp2 = true;
47609 }
47610 if (obj2) {
47611 arg3 = obj2;
47612 }
47613 {
47614 PyThreadState* __tstate = wxPyBeginAllowThreads();
47615 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47616 wxPyEndAllowThreads(__tstate);
47617 if (PyErr_Occurred()) SWIG_fail;
47618 }
47619 resultobj = SWIG_From_int(static_cast< int >(result));
47620 {
47621 if (temp2)
47622 delete arg2;
47623 }
47624 return resultobj;
47625 fail:
47626 {
47627 if (temp2)
47628 delete arg2;
47629 }
47630 return NULL;
47631 }
47632
47633
47634 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47635 PyObject *resultobj = 0;
47636 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47637 wxArrayString *arg2 = 0 ;
47638 void *argp1 = 0 ;
47639 int res1 = 0 ;
47640 bool temp2 = false ;
47641 PyObject * obj0 = 0 ;
47642 PyObject * obj1 = 0 ;
47643 char * kwnames[] = {
47644 (char *) "self",(char *) "strings", NULL
47645 };
47646
47647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
47648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47649 if (!SWIG_IsOK(res1)) {
47650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47651 }
47652 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47653 {
47654 if (! PySequence_Check(obj1)) {
47655 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
47656 SWIG_fail;
47657 }
47658 arg2 = new wxArrayString;
47659 temp2 = true;
47660 int i, len=PySequence_Length(obj1);
47661 for (i=0; i<len; i++) {
47662 PyObject* item = PySequence_GetItem(obj1, i);
47663 wxString* s = wxString_in_helper(item);
47664 if (PyErr_Occurred()) SWIG_fail;
47665 arg2->Add(*s);
47666 delete s;
47667 Py_DECREF(item);
47668 }
47669 }
47670 {
47671 PyThreadState* __tstate = wxPyBeginAllowThreads();
47672 (arg1)->Append((wxArrayString const &)*arg2);
47673 wxPyEndAllowThreads(__tstate);
47674 if (PyErr_Occurred()) SWIG_fail;
47675 }
47676 resultobj = SWIG_Py_Void();
47677 {
47678 if (temp2) delete arg2;
47679 }
47680 return resultobj;
47681 fail:
47682 {
47683 if (temp2) delete arg2;
47684 }
47685 return NULL;
47686 }
47687
47688
47689 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47690 PyObject *resultobj = 0;
47691 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47692 wxString *arg2 = 0 ;
47693 unsigned int arg3 ;
47694 PyObject *arg4 = (PyObject *) NULL ;
47695 int result;
47696 void *argp1 = 0 ;
47697 int res1 = 0 ;
47698 bool temp2 = false ;
47699 unsigned int val3 ;
47700 int ecode3 = 0 ;
47701 PyObject * obj0 = 0 ;
47702 PyObject * obj1 = 0 ;
47703 PyObject * obj2 = 0 ;
47704 PyObject * obj3 = 0 ;
47705 char * kwnames[] = {
47706 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
47707 };
47708
47709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47711 if (!SWIG_IsOK(res1)) {
47712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47713 }
47714 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47715 {
47716 arg2 = wxString_in_helper(obj1);
47717 if (arg2 == NULL) SWIG_fail;
47718 temp2 = true;
47719 }
47720 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
47721 if (!SWIG_IsOK(ecode3)) {
47722 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
47723 }
47724 arg3 = static_cast< unsigned int >(val3);
47725 if (obj3) {
47726 arg4 = obj3;
47727 }
47728 {
47729 PyThreadState* __tstate = wxPyBeginAllowThreads();
47730 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
47731 wxPyEndAllowThreads(__tstate);
47732 if (PyErr_Occurred()) SWIG_fail;
47733 }
47734 resultobj = SWIG_From_int(static_cast< int >(result));
47735 {
47736 if (temp2)
47737 delete arg2;
47738 }
47739 return resultobj;
47740 fail:
47741 {
47742 if (temp2)
47743 delete arg2;
47744 }
47745 return NULL;
47746 }
47747
47748
47749 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47750 PyObject *resultobj = 0;
47751 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47752 void *argp1 = 0 ;
47753 int res1 = 0 ;
47754 PyObject *swig_obj[1] ;
47755
47756 if (!args) SWIG_fail;
47757 swig_obj[0] = args;
47758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47759 if (!SWIG_IsOK(res1)) {
47760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47761 }
47762 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47763 {
47764 PyThreadState* __tstate = wxPyBeginAllowThreads();
47765 (arg1)->Clear();
47766 wxPyEndAllowThreads(__tstate);
47767 if (PyErr_Occurred()) SWIG_fail;
47768 }
47769 resultobj = SWIG_Py_Void();
47770 return resultobj;
47771 fail:
47772 return NULL;
47773 }
47774
47775
47776 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47777 PyObject *resultobj = 0;
47778 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47779 unsigned int arg2 ;
47780 void *argp1 = 0 ;
47781 int res1 = 0 ;
47782 unsigned int val2 ;
47783 int ecode2 = 0 ;
47784 PyObject * obj0 = 0 ;
47785 PyObject * obj1 = 0 ;
47786 char * kwnames[] = {
47787 (char *) "self",(char *) "n", NULL
47788 };
47789
47790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
47791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47792 if (!SWIG_IsOK(res1)) {
47793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47794 }
47795 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47796 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47797 if (!SWIG_IsOK(ecode2)) {
47798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
47799 }
47800 arg2 = static_cast< unsigned int >(val2);
47801 {
47802 PyThreadState* __tstate = wxPyBeginAllowThreads();
47803 (arg1)->Delete(arg2);
47804 wxPyEndAllowThreads(__tstate);
47805 if (PyErr_Occurred()) SWIG_fail;
47806 }
47807 resultobj = SWIG_Py_Void();
47808 return resultobj;
47809 fail:
47810 return NULL;
47811 }
47812
47813
47814 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47815 PyObject *resultobj = 0;
47816 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47817 unsigned int arg2 ;
47818 PyObject *result = 0 ;
47819 void *argp1 = 0 ;
47820 int res1 = 0 ;
47821 unsigned int val2 ;
47822 int ecode2 = 0 ;
47823 PyObject * obj0 = 0 ;
47824 PyObject * obj1 = 0 ;
47825 char * kwnames[] = {
47826 (char *) "self",(char *) "n", NULL
47827 };
47828
47829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
47830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47831 if (!SWIG_IsOK(res1)) {
47832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47833 }
47834 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47835 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47836 if (!SWIG_IsOK(ecode2)) {
47837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47838 }
47839 arg2 = static_cast< unsigned int >(val2);
47840 {
47841 PyThreadState* __tstate = wxPyBeginAllowThreads();
47842 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
47843 wxPyEndAllowThreads(__tstate);
47844 if (PyErr_Occurred()) SWIG_fail;
47845 }
47846 resultobj = result;
47847 return resultobj;
47848 fail:
47849 return NULL;
47850 }
47851
47852
47853 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47854 PyObject *resultobj = 0;
47855 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47856 unsigned int arg2 ;
47857 PyObject *arg3 = (PyObject *) 0 ;
47858 void *argp1 = 0 ;
47859 int res1 = 0 ;
47860 unsigned int val2 ;
47861 int ecode2 = 0 ;
47862 PyObject * obj0 = 0 ;
47863 PyObject * obj1 = 0 ;
47864 PyObject * obj2 = 0 ;
47865 char * kwnames[] = {
47866 (char *) "self",(char *) "n",(char *) "clientData", NULL
47867 };
47868
47869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47871 if (!SWIG_IsOK(res1)) {
47872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47873 }
47874 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47875 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47876 if (!SWIG_IsOK(ecode2)) {
47877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47878 }
47879 arg2 = static_cast< unsigned int >(val2);
47880 arg3 = obj2;
47881 {
47882 PyThreadState* __tstate = wxPyBeginAllowThreads();
47883 wxItemContainer_SetClientData(arg1,arg2,arg3);
47884 wxPyEndAllowThreads(__tstate);
47885 if (PyErr_Occurred()) SWIG_fail;
47886 }
47887 resultobj = SWIG_Py_Void();
47888 return resultobj;
47889 fail:
47890 return NULL;
47891 }
47892
47893
47894 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47895 PyObject *resultobj = 0;
47896 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47897 unsigned int result;
47898 void *argp1 = 0 ;
47899 int res1 = 0 ;
47900 PyObject *swig_obj[1] ;
47901
47902 if (!args) SWIG_fail;
47903 swig_obj[0] = args;
47904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47905 if (!SWIG_IsOK(res1)) {
47906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47907 }
47908 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47909 {
47910 PyThreadState* __tstate = wxPyBeginAllowThreads();
47911 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
47912 wxPyEndAllowThreads(__tstate);
47913 if (PyErr_Occurred()) SWIG_fail;
47914 }
47915 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
47916 return resultobj;
47917 fail:
47918 return NULL;
47919 }
47920
47921
47922 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47923 PyObject *resultobj = 0;
47924 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47925 bool result;
47926 void *argp1 = 0 ;
47927 int res1 = 0 ;
47928 PyObject *swig_obj[1] ;
47929
47930 if (!args) SWIG_fail;
47931 swig_obj[0] = args;
47932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47933 if (!SWIG_IsOK(res1)) {
47934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47935 }
47936 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47937 {
47938 PyThreadState* __tstate = wxPyBeginAllowThreads();
47939 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
47940 wxPyEndAllowThreads(__tstate);
47941 if (PyErr_Occurred()) SWIG_fail;
47942 }
47943 {
47944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47945 }
47946 return resultobj;
47947 fail:
47948 return NULL;
47949 }
47950
47951
47952 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47953 PyObject *resultobj = 0;
47954 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47955 unsigned int arg2 ;
47956 wxString result;
47957 void *argp1 = 0 ;
47958 int res1 = 0 ;
47959 unsigned int val2 ;
47960 int ecode2 = 0 ;
47961 PyObject * obj0 = 0 ;
47962 PyObject * obj1 = 0 ;
47963 char * kwnames[] = {
47964 (char *) "self",(char *) "n", NULL
47965 };
47966
47967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
47968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47969 if (!SWIG_IsOK(res1)) {
47970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47971 }
47972 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47973 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47974 if (!SWIG_IsOK(ecode2)) {
47975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
47976 }
47977 arg2 = static_cast< unsigned int >(val2);
47978 {
47979 PyThreadState* __tstate = wxPyBeginAllowThreads();
47980 result = ((wxItemContainer const *)arg1)->GetString(arg2);
47981 wxPyEndAllowThreads(__tstate);
47982 if (PyErr_Occurred()) SWIG_fail;
47983 }
47984 {
47985 #if wxUSE_UNICODE
47986 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47987 #else
47988 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47989 #endif
47990 }
47991 return resultobj;
47992 fail:
47993 return NULL;
47994 }
47995
47996
47997 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47998 PyObject *resultobj = 0;
47999 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48000 wxArrayString result;
48001 void *argp1 = 0 ;
48002 int res1 = 0 ;
48003 PyObject *swig_obj[1] ;
48004
48005 if (!args) SWIG_fail;
48006 swig_obj[0] = args;
48007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48008 if (!SWIG_IsOK(res1)) {
48009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48010 }
48011 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48012 {
48013 PyThreadState* __tstate = wxPyBeginAllowThreads();
48014 result = ((wxItemContainer const *)arg1)->GetStrings();
48015 wxPyEndAllowThreads(__tstate);
48016 if (PyErr_Occurred()) SWIG_fail;
48017 }
48018 {
48019 resultobj = wxArrayString2PyList_helper(result);
48020 }
48021 return resultobj;
48022 fail:
48023 return NULL;
48024 }
48025
48026
48027 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48028 PyObject *resultobj = 0;
48029 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48030 unsigned int arg2 ;
48031 wxString *arg3 = 0 ;
48032 void *argp1 = 0 ;
48033 int res1 = 0 ;
48034 unsigned int val2 ;
48035 int ecode2 = 0 ;
48036 bool temp3 = false ;
48037 PyObject * obj0 = 0 ;
48038 PyObject * obj1 = 0 ;
48039 PyObject * obj2 = 0 ;
48040 char * kwnames[] = {
48041 (char *) "self",(char *) "n",(char *) "s", NULL
48042 };
48043
48044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48046 if (!SWIG_IsOK(res1)) {
48047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48048 }
48049 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48050 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
48051 if (!SWIG_IsOK(ecode2)) {
48052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
48053 }
48054 arg2 = static_cast< unsigned int >(val2);
48055 {
48056 arg3 = wxString_in_helper(obj2);
48057 if (arg3 == NULL) SWIG_fail;
48058 temp3 = true;
48059 }
48060 {
48061 PyThreadState* __tstate = wxPyBeginAllowThreads();
48062 (arg1)->SetString(arg2,(wxString const &)*arg3);
48063 wxPyEndAllowThreads(__tstate);
48064 if (PyErr_Occurred()) SWIG_fail;
48065 }
48066 resultobj = SWIG_Py_Void();
48067 {
48068 if (temp3)
48069 delete arg3;
48070 }
48071 return resultobj;
48072 fail:
48073 {
48074 if (temp3)
48075 delete arg3;
48076 }
48077 return NULL;
48078 }
48079
48080
48081 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48082 PyObject *resultobj = 0;
48083 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48084 wxString *arg2 = 0 ;
48085 int result;
48086 void *argp1 = 0 ;
48087 int res1 = 0 ;
48088 bool temp2 = false ;
48089 PyObject * obj0 = 0 ;
48090 PyObject * obj1 = 0 ;
48091 char * kwnames[] = {
48092 (char *) "self",(char *) "s", NULL
48093 };
48094
48095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48097 if (!SWIG_IsOK(res1)) {
48098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48099 }
48100 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48101 {
48102 arg2 = wxString_in_helper(obj1);
48103 if (arg2 == NULL) SWIG_fail;
48104 temp2 = true;
48105 }
48106 {
48107 PyThreadState* __tstate = wxPyBeginAllowThreads();
48108 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48109 wxPyEndAllowThreads(__tstate);
48110 if (PyErr_Occurred()) SWIG_fail;
48111 }
48112 resultobj = SWIG_From_int(static_cast< int >(result));
48113 {
48114 if (temp2)
48115 delete arg2;
48116 }
48117 return resultobj;
48118 fail:
48119 {
48120 if (temp2)
48121 delete arg2;
48122 }
48123 return NULL;
48124 }
48125
48126
48127 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48128 PyObject *resultobj = 0;
48129 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48130 int arg2 ;
48131 void *argp1 = 0 ;
48132 int res1 = 0 ;
48133 int val2 ;
48134 int ecode2 = 0 ;
48135 PyObject * obj0 = 0 ;
48136 PyObject * obj1 = 0 ;
48137 char * kwnames[] = {
48138 (char *) "self",(char *) "n", NULL
48139 };
48140
48141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48143 if (!SWIG_IsOK(res1)) {
48144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48145 }
48146 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48147 ecode2 = SWIG_AsVal_int(obj1, &val2);
48148 if (!SWIG_IsOK(ecode2)) {
48149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48150 }
48151 arg2 = static_cast< int >(val2);
48152 {
48153 PyThreadState* __tstate = wxPyBeginAllowThreads();
48154 (arg1)->SetSelection(arg2);
48155 wxPyEndAllowThreads(__tstate);
48156 if (PyErr_Occurred()) SWIG_fail;
48157 }
48158 resultobj = SWIG_Py_Void();
48159 return resultobj;
48160 fail:
48161 return NULL;
48162 }
48163
48164
48165 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48166 PyObject *resultobj = 0;
48167 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48168 int result;
48169 void *argp1 = 0 ;
48170 int res1 = 0 ;
48171 PyObject *swig_obj[1] ;
48172
48173 if (!args) SWIG_fail;
48174 swig_obj[0] = args;
48175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48176 if (!SWIG_IsOK(res1)) {
48177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48178 }
48179 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48180 {
48181 PyThreadState* __tstate = wxPyBeginAllowThreads();
48182 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48183 wxPyEndAllowThreads(__tstate);
48184 if (PyErr_Occurred()) SWIG_fail;
48185 }
48186 resultobj = SWIG_From_int(static_cast< int >(result));
48187 return resultobj;
48188 fail:
48189 return NULL;
48190 }
48191
48192
48193 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48194 PyObject *resultobj = 0;
48195 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48196 wxString *arg2 = 0 ;
48197 bool result;
48198 void *argp1 = 0 ;
48199 int res1 = 0 ;
48200 bool temp2 = false ;
48201 PyObject * obj0 = 0 ;
48202 PyObject * obj1 = 0 ;
48203 char * kwnames[] = {
48204 (char *) "self",(char *) "s", NULL
48205 };
48206
48207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48209 if (!SWIG_IsOK(res1)) {
48210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48211 }
48212 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48213 {
48214 arg2 = wxString_in_helper(obj1);
48215 if (arg2 == NULL) SWIG_fail;
48216 temp2 = true;
48217 }
48218 {
48219 PyThreadState* __tstate = wxPyBeginAllowThreads();
48220 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48221 wxPyEndAllowThreads(__tstate);
48222 if (PyErr_Occurred()) SWIG_fail;
48223 }
48224 {
48225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48226 }
48227 {
48228 if (temp2)
48229 delete arg2;
48230 }
48231 return resultobj;
48232 fail:
48233 {
48234 if (temp2)
48235 delete arg2;
48236 }
48237 return NULL;
48238 }
48239
48240
48241 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48242 PyObject *resultobj = 0;
48243 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48244 wxString result;
48245 void *argp1 = 0 ;
48246 int res1 = 0 ;
48247 PyObject *swig_obj[1] ;
48248
48249 if (!args) SWIG_fail;
48250 swig_obj[0] = args;
48251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48252 if (!SWIG_IsOK(res1)) {
48253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48254 }
48255 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48256 {
48257 PyThreadState* __tstate = wxPyBeginAllowThreads();
48258 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48259 wxPyEndAllowThreads(__tstate);
48260 if (PyErr_Occurred()) SWIG_fail;
48261 }
48262 {
48263 #if wxUSE_UNICODE
48264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48265 #else
48266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48267 #endif
48268 }
48269 return resultobj;
48270 fail:
48271 return NULL;
48272 }
48273
48274
48275 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48276 PyObject *resultobj = 0;
48277 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48278 int arg2 ;
48279 void *argp1 = 0 ;
48280 int res1 = 0 ;
48281 int val2 ;
48282 int ecode2 = 0 ;
48283 PyObject * obj0 = 0 ;
48284 PyObject * obj1 = 0 ;
48285 char * kwnames[] = {
48286 (char *) "self",(char *) "n", NULL
48287 };
48288
48289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48291 if (!SWIG_IsOK(res1)) {
48292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48293 }
48294 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48295 ecode2 = SWIG_AsVal_int(obj1, &val2);
48296 if (!SWIG_IsOK(ecode2)) {
48297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48298 }
48299 arg2 = static_cast< int >(val2);
48300 {
48301 PyThreadState* __tstate = wxPyBeginAllowThreads();
48302 (arg1)->Select(arg2);
48303 wxPyEndAllowThreads(__tstate);
48304 if (PyErr_Occurred()) SWIG_fail;
48305 }
48306 resultobj = SWIG_Py_Void();
48307 return resultobj;
48308 fail:
48309 return NULL;
48310 }
48311
48312
48313 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48314 PyObject *obj;
48315 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48316 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48317 return SWIG_Py_Void();
48318 }
48319
48320 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48321 PyObject *obj;
48322 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48323 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48324 return SWIG_Py_Void();
48325 }
48326
48327 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48328 PyObject *resultobj = 0;
48329 wxSizerItem *result = 0 ;
48330
48331 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
48332 {
48333 PyThreadState* __tstate = wxPyBeginAllowThreads();
48334 result = (wxSizerItem *)new wxSizerItem();
48335 wxPyEndAllowThreads(__tstate);
48336 if (PyErr_Occurred()) SWIG_fail;
48337 }
48338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
48339 return resultobj;
48340 fail:
48341 return NULL;
48342 }
48343
48344
48345 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48346 PyObject *resultobj = 0;
48347 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48348 void *argp1 = 0 ;
48349 int res1 = 0 ;
48350 PyObject *swig_obj[1] ;
48351
48352 if (!args) SWIG_fail;
48353 swig_obj[0] = args;
48354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48355 if (!SWIG_IsOK(res1)) {
48356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48357 }
48358 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48359 {
48360 PyThreadState* __tstate = wxPyBeginAllowThreads();
48361 delete arg1;
48362
48363 wxPyEndAllowThreads(__tstate);
48364 if (PyErr_Occurred()) SWIG_fail;
48365 }
48366 resultobj = SWIG_Py_Void();
48367 return resultobj;
48368 fail:
48369 return NULL;
48370 }
48371
48372
48373 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48374 PyObject *resultobj = 0;
48375 wxWindow *arg1 = (wxWindow *) 0 ;
48376 int arg2 ;
48377 int arg3 ;
48378 int arg4 ;
48379 PyObject *arg5 = (PyObject *) NULL ;
48380 wxSizerItem *result = 0 ;
48381 void *argp1 = 0 ;
48382 int res1 = 0 ;
48383 int val2 ;
48384 int ecode2 = 0 ;
48385 int val3 ;
48386 int ecode3 = 0 ;
48387 int val4 ;
48388 int ecode4 = 0 ;
48389 PyObject * obj0 = 0 ;
48390 PyObject * obj1 = 0 ;
48391 PyObject * obj2 = 0 ;
48392 PyObject * obj3 = 0 ;
48393 PyObject * obj4 = 0 ;
48394 char * kwnames[] = {
48395 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48396 };
48397
48398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48400 if (!SWIG_IsOK(res1)) {
48401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
48402 }
48403 arg1 = reinterpret_cast< wxWindow * >(argp1);
48404 ecode2 = SWIG_AsVal_int(obj1, &val2);
48405 if (!SWIG_IsOK(ecode2)) {
48406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
48407 }
48408 arg2 = static_cast< int >(val2);
48409 ecode3 = SWIG_AsVal_int(obj2, &val3);
48410 if (!SWIG_IsOK(ecode3)) {
48411 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
48412 }
48413 arg3 = static_cast< int >(val3);
48414 ecode4 = SWIG_AsVal_int(obj3, &val4);
48415 if (!SWIG_IsOK(ecode4)) {
48416 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
48417 }
48418 arg4 = static_cast< int >(val4);
48419 if (obj4) {
48420 arg5 = obj4;
48421 }
48422 {
48423 PyThreadState* __tstate = wxPyBeginAllowThreads();
48424 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48425 wxPyEndAllowThreads(__tstate);
48426 if (PyErr_Occurred()) SWIG_fail;
48427 }
48428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48429 return resultobj;
48430 fail:
48431 return NULL;
48432 }
48433
48434
48435 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48436 PyObject *resultobj = 0;
48437 int arg1 ;
48438 int arg2 ;
48439 int arg3 ;
48440 int arg4 ;
48441 int arg5 ;
48442 PyObject *arg6 = (PyObject *) NULL ;
48443 wxSizerItem *result = 0 ;
48444 int val1 ;
48445 int ecode1 = 0 ;
48446 int val2 ;
48447 int ecode2 = 0 ;
48448 int val3 ;
48449 int ecode3 = 0 ;
48450 int val4 ;
48451 int ecode4 = 0 ;
48452 int val5 ;
48453 int ecode5 = 0 ;
48454 PyObject * obj0 = 0 ;
48455 PyObject * obj1 = 0 ;
48456 PyObject * obj2 = 0 ;
48457 PyObject * obj3 = 0 ;
48458 PyObject * obj4 = 0 ;
48459 PyObject * obj5 = 0 ;
48460 char * kwnames[] = {
48461 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48462 };
48463
48464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
48465 ecode1 = SWIG_AsVal_int(obj0, &val1);
48466 if (!SWIG_IsOK(ecode1)) {
48467 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
48468 }
48469 arg1 = static_cast< int >(val1);
48470 ecode2 = SWIG_AsVal_int(obj1, &val2);
48471 if (!SWIG_IsOK(ecode2)) {
48472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
48473 }
48474 arg2 = static_cast< int >(val2);
48475 ecode3 = SWIG_AsVal_int(obj2, &val3);
48476 if (!SWIG_IsOK(ecode3)) {
48477 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
48478 }
48479 arg3 = static_cast< int >(val3);
48480 ecode4 = SWIG_AsVal_int(obj3, &val4);
48481 if (!SWIG_IsOK(ecode4)) {
48482 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
48483 }
48484 arg4 = static_cast< int >(val4);
48485 ecode5 = SWIG_AsVal_int(obj4, &val5);
48486 if (!SWIG_IsOK(ecode5)) {
48487 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
48488 }
48489 arg5 = static_cast< int >(val5);
48490 if (obj5) {
48491 arg6 = obj5;
48492 }
48493 {
48494 PyThreadState* __tstate = wxPyBeginAllowThreads();
48495 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
48496 wxPyEndAllowThreads(__tstate);
48497 if (PyErr_Occurred()) SWIG_fail;
48498 }
48499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48500 return resultobj;
48501 fail:
48502 return NULL;
48503 }
48504
48505
48506 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48507 PyObject *resultobj = 0;
48508 wxSizer *arg1 = (wxSizer *) 0 ;
48509 int arg2 ;
48510 int arg3 ;
48511 int arg4 ;
48512 PyObject *arg5 = (PyObject *) NULL ;
48513 wxSizerItem *result = 0 ;
48514 int res1 = 0 ;
48515 int val2 ;
48516 int ecode2 = 0 ;
48517 int val3 ;
48518 int ecode3 = 0 ;
48519 int val4 ;
48520 int ecode4 = 0 ;
48521 PyObject * obj0 = 0 ;
48522 PyObject * obj1 = 0 ;
48523 PyObject * obj2 = 0 ;
48524 PyObject * obj3 = 0 ;
48525 PyObject * obj4 = 0 ;
48526 char * kwnames[] = {
48527 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48528 };
48529
48530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48531 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
48532 if (!SWIG_IsOK(res1)) {
48533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48534 }
48535 ecode2 = SWIG_AsVal_int(obj1, &val2);
48536 if (!SWIG_IsOK(ecode2)) {
48537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
48538 }
48539 arg2 = static_cast< int >(val2);
48540 ecode3 = SWIG_AsVal_int(obj2, &val3);
48541 if (!SWIG_IsOK(ecode3)) {
48542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
48543 }
48544 arg3 = static_cast< int >(val3);
48545 ecode4 = SWIG_AsVal_int(obj3, &val4);
48546 if (!SWIG_IsOK(ecode4)) {
48547 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
48548 }
48549 arg4 = static_cast< int >(val4);
48550 if (obj4) {
48551 arg5 = obj4;
48552 }
48553 {
48554 PyThreadState* __tstate = wxPyBeginAllowThreads();
48555 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48556 wxPyEndAllowThreads(__tstate);
48557 if (PyErr_Occurred()) SWIG_fail;
48558 }
48559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48560 return resultobj;
48561 fail:
48562 return NULL;
48563 }
48564
48565
48566 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48567 PyObject *resultobj = 0;
48568 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48569 void *argp1 = 0 ;
48570 int res1 = 0 ;
48571 PyObject *swig_obj[1] ;
48572
48573 if (!args) SWIG_fail;
48574 swig_obj[0] = args;
48575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48576 if (!SWIG_IsOK(res1)) {
48577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48578 }
48579 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48580 {
48581 PyThreadState* __tstate = wxPyBeginAllowThreads();
48582 (arg1)->DeleteWindows();
48583 wxPyEndAllowThreads(__tstate);
48584 if (PyErr_Occurred()) SWIG_fail;
48585 }
48586 resultobj = SWIG_Py_Void();
48587 return resultobj;
48588 fail:
48589 return NULL;
48590 }
48591
48592
48593 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48594 PyObject *resultobj = 0;
48595 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48596 void *argp1 = 0 ;
48597 int res1 = 0 ;
48598 PyObject *swig_obj[1] ;
48599
48600 if (!args) SWIG_fail;
48601 swig_obj[0] = args;
48602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48603 if (!SWIG_IsOK(res1)) {
48604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48605 }
48606 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48607 {
48608 PyThreadState* __tstate = wxPyBeginAllowThreads();
48609 (arg1)->DetachSizer();
48610 wxPyEndAllowThreads(__tstate);
48611 if (PyErr_Occurred()) SWIG_fail;
48612 }
48613 resultobj = SWIG_Py_Void();
48614 return resultobj;
48615 fail:
48616 return NULL;
48617 }
48618
48619
48620 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48621 PyObject *resultobj = 0;
48622 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48623 wxSize result;
48624 void *argp1 = 0 ;
48625 int res1 = 0 ;
48626 PyObject *swig_obj[1] ;
48627
48628 if (!args) SWIG_fail;
48629 swig_obj[0] = args;
48630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48631 if (!SWIG_IsOK(res1)) {
48632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48633 }
48634 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48635 {
48636 PyThreadState* __tstate = wxPyBeginAllowThreads();
48637 result = (arg1)->GetSize();
48638 wxPyEndAllowThreads(__tstate);
48639 if (PyErr_Occurred()) SWIG_fail;
48640 }
48641 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48642 return resultobj;
48643 fail:
48644 return NULL;
48645 }
48646
48647
48648 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48649 PyObject *resultobj = 0;
48650 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48651 wxSize result;
48652 void *argp1 = 0 ;
48653 int res1 = 0 ;
48654 PyObject *swig_obj[1] ;
48655
48656 if (!args) SWIG_fail;
48657 swig_obj[0] = args;
48658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48659 if (!SWIG_IsOK(res1)) {
48660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48661 }
48662 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48663 {
48664 PyThreadState* __tstate = wxPyBeginAllowThreads();
48665 result = (arg1)->CalcMin();
48666 wxPyEndAllowThreads(__tstate);
48667 if (PyErr_Occurred()) SWIG_fail;
48668 }
48669 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48670 return resultobj;
48671 fail:
48672 return NULL;
48673 }
48674
48675
48676 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48677 PyObject *resultobj = 0;
48678 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48679 wxPoint *arg2 = 0 ;
48680 wxSize *arg3 = 0 ;
48681 void *argp1 = 0 ;
48682 int res1 = 0 ;
48683 wxPoint temp2 ;
48684 wxSize temp3 ;
48685 PyObject * obj0 = 0 ;
48686 PyObject * obj1 = 0 ;
48687 PyObject * obj2 = 0 ;
48688 char * kwnames[] = {
48689 (char *) "self",(char *) "pos",(char *) "size", NULL
48690 };
48691
48692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48694 if (!SWIG_IsOK(res1)) {
48695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48696 }
48697 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48698 {
48699 arg2 = &temp2;
48700 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
48701 }
48702 {
48703 arg3 = &temp3;
48704 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48705 }
48706 {
48707 PyThreadState* __tstate = wxPyBeginAllowThreads();
48708 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
48709 wxPyEndAllowThreads(__tstate);
48710 if (PyErr_Occurred()) SWIG_fail;
48711 }
48712 resultobj = SWIG_Py_Void();
48713 return resultobj;
48714 fail:
48715 return NULL;
48716 }
48717
48718
48719 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48720 PyObject *resultobj = 0;
48721 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48722 wxSize result;
48723 void *argp1 = 0 ;
48724 int res1 = 0 ;
48725 PyObject *swig_obj[1] ;
48726
48727 if (!args) SWIG_fail;
48728 swig_obj[0] = args;
48729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48730 if (!SWIG_IsOK(res1)) {
48731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48732 }
48733 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48734 {
48735 PyThreadState* __tstate = wxPyBeginAllowThreads();
48736 result = (arg1)->GetMinSize();
48737 wxPyEndAllowThreads(__tstate);
48738 if (PyErr_Occurred()) SWIG_fail;
48739 }
48740 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48741 return resultobj;
48742 fail:
48743 return NULL;
48744 }
48745
48746
48747 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48748 PyObject *resultobj = 0;
48749 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48750 wxSize result;
48751 void *argp1 = 0 ;
48752 int res1 = 0 ;
48753 PyObject *swig_obj[1] ;
48754
48755 if (!args) SWIG_fail;
48756 swig_obj[0] = args;
48757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48758 if (!SWIG_IsOK(res1)) {
48759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
48760 }
48761 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48762 {
48763 PyThreadState* __tstate = wxPyBeginAllowThreads();
48764 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
48765 wxPyEndAllowThreads(__tstate);
48766 if (PyErr_Occurred()) SWIG_fail;
48767 }
48768 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48769 return resultobj;
48770 fail:
48771 return NULL;
48772 }
48773
48774
48775 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48776 PyObject *resultobj = 0;
48777 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48778 int arg2 ;
48779 int arg3 ;
48780 void *argp1 = 0 ;
48781 int res1 = 0 ;
48782 int val2 ;
48783 int ecode2 = 0 ;
48784 int val3 ;
48785 int ecode3 = 0 ;
48786 PyObject * obj0 = 0 ;
48787 PyObject * obj1 = 0 ;
48788 PyObject * obj2 = 0 ;
48789 char * kwnames[] = {
48790 (char *) "self",(char *) "x",(char *) "y", NULL
48791 };
48792
48793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48795 if (!SWIG_IsOK(res1)) {
48796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48797 }
48798 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48799 ecode2 = SWIG_AsVal_int(obj1, &val2);
48800 if (!SWIG_IsOK(ecode2)) {
48801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
48802 }
48803 arg2 = static_cast< int >(val2);
48804 ecode3 = SWIG_AsVal_int(obj2, &val3);
48805 if (!SWIG_IsOK(ecode3)) {
48806 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
48807 }
48808 arg3 = static_cast< int >(val3);
48809 {
48810 PyThreadState* __tstate = wxPyBeginAllowThreads();
48811 (arg1)->SetInitSize(arg2,arg3);
48812 wxPyEndAllowThreads(__tstate);
48813 if (PyErr_Occurred()) SWIG_fail;
48814 }
48815 resultobj = SWIG_Py_Void();
48816 return resultobj;
48817 fail:
48818 return NULL;
48819 }
48820
48821
48822 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48823 PyObject *resultobj = 0;
48824 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48825 int arg2 ;
48826 int arg3 ;
48827 void *argp1 = 0 ;
48828 int res1 = 0 ;
48829 int val2 ;
48830 int ecode2 = 0 ;
48831 int val3 ;
48832 int ecode3 = 0 ;
48833 PyObject * obj0 = 0 ;
48834 PyObject * obj1 = 0 ;
48835 PyObject * obj2 = 0 ;
48836 char * kwnames[] = {
48837 (char *) "self",(char *) "width",(char *) "height", NULL
48838 };
48839
48840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48842 if (!SWIG_IsOK(res1)) {
48843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48844 }
48845 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48846 ecode2 = SWIG_AsVal_int(obj1, &val2);
48847 if (!SWIG_IsOK(ecode2)) {
48848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
48849 }
48850 arg2 = static_cast< int >(val2);
48851 ecode3 = SWIG_AsVal_int(obj2, &val3);
48852 if (!SWIG_IsOK(ecode3)) {
48853 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
48854 }
48855 arg3 = static_cast< int >(val3);
48856 {
48857 PyThreadState* __tstate = wxPyBeginAllowThreads();
48858 (arg1)->SetRatio(arg2,arg3);
48859 wxPyEndAllowThreads(__tstate);
48860 if (PyErr_Occurred()) SWIG_fail;
48861 }
48862 resultobj = SWIG_Py_Void();
48863 return resultobj;
48864 fail:
48865 return NULL;
48866 }
48867
48868
48869 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48870 PyObject *resultobj = 0;
48871 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48872 wxSize *arg2 = 0 ;
48873 void *argp1 = 0 ;
48874 int res1 = 0 ;
48875 wxSize temp2 ;
48876 PyObject * obj0 = 0 ;
48877 PyObject * obj1 = 0 ;
48878 char * kwnames[] = {
48879 (char *) "self",(char *) "size", NULL
48880 };
48881
48882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
48883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48884 if (!SWIG_IsOK(res1)) {
48885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48886 }
48887 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48888 {
48889 arg2 = &temp2;
48890 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48891 }
48892 {
48893 PyThreadState* __tstate = wxPyBeginAllowThreads();
48894 (arg1)->SetRatio((wxSize const &)*arg2);
48895 wxPyEndAllowThreads(__tstate);
48896 if (PyErr_Occurred()) SWIG_fail;
48897 }
48898 resultobj = SWIG_Py_Void();
48899 return resultobj;
48900 fail:
48901 return NULL;
48902 }
48903
48904
48905 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48906 PyObject *resultobj = 0;
48907 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48908 float arg2 ;
48909 void *argp1 = 0 ;
48910 int res1 = 0 ;
48911 float val2 ;
48912 int ecode2 = 0 ;
48913 PyObject * obj0 = 0 ;
48914 PyObject * obj1 = 0 ;
48915 char * kwnames[] = {
48916 (char *) "self",(char *) "ratio", NULL
48917 };
48918
48919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
48920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48921 if (!SWIG_IsOK(res1)) {
48922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48923 }
48924 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48925 ecode2 = SWIG_AsVal_float(obj1, &val2);
48926 if (!SWIG_IsOK(ecode2)) {
48927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
48928 }
48929 arg2 = static_cast< float >(val2);
48930 {
48931 PyThreadState* __tstate = wxPyBeginAllowThreads();
48932 (arg1)->SetRatio(arg2);
48933 wxPyEndAllowThreads(__tstate);
48934 if (PyErr_Occurred()) SWIG_fail;
48935 }
48936 resultobj = SWIG_Py_Void();
48937 return resultobj;
48938 fail:
48939 return NULL;
48940 }
48941
48942
48943 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48944 PyObject *resultobj = 0;
48945 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48946 float result;
48947 void *argp1 = 0 ;
48948 int res1 = 0 ;
48949 PyObject *swig_obj[1] ;
48950
48951 if (!args) SWIG_fail;
48952 swig_obj[0] = args;
48953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48954 if (!SWIG_IsOK(res1)) {
48955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48956 }
48957 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48958 {
48959 PyThreadState* __tstate = wxPyBeginAllowThreads();
48960 result = (float)(arg1)->GetRatio();
48961 wxPyEndAllowThreads(__tstate);
48962 if (PyErr_Occurred()) SWIG_fail;
48963 }
48964 resultobj = SWIG_From_float(static_cast< float >(result));
48965 return resultobj;
48966 fail:
48967 return NULL;
48968 }
48969
48970
48971 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48972 PyObject *resultobj = 0;
48973 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48974 wxRect result;
48975 void *argp1 = 0 ;
48976 int res1 = 0 ;
48977 PyObject *swig_obj[1] ;
48978
48979 if (!args) SWIG_fail;
48980 swig_obj[0] = args;
48981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48982 if (!SWIG_IsOK(res1)) {
48983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48984 }
48985 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48986 {
48987 PyThreadState* __tstate = wxPyBeginAllowThreads();
48988 result = (arg1)->GetRect();
48989 wxPyEndAllowThreads(__tstate);
48990 if (PyErr_Occurred()) SWIG_fail;
48991 }
48992 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
48993 return resultobj;
48994 fail:
48995 return NULL;
48996 }
48997
48998
48999 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49000 PyObject *resultobj = 0;
49001 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49002 bool result;
49003 void *argp1 = 0 ;
49004 int res1 = 0 ;
49005 PyObject *swig_obj[1] ;
49006
49007 if (!args) SWIG_fail;
49008 swig_obj[0] = args;
49009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49010 if (!SWIG_IsOK(res1)) {
49011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49012 }
49013 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49014 {
49015 PyThreadState* __tstate = wxPyBeginAllowThreads();
49016 result = (bool)(arg1)->IsWindow();
49017 wxPyEndAllowThreads(__tstate);
49018 if (PyErr_Occurred()) SWIG_fail;
49019 }
49020 {
49021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49022 }
49023 return resultobj;
49024 fail:
49025 return NULL;
49026 }
49027
49028
49029 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49030 PyObject *resultobj = 0;
49031 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49032 bool result;
49033 void *argp1 = 0 ;
49034 int res1 = 0 ;
49035 PyObject *swig_obj[1] ;
49036
49037 if (!args) SWIG_fail;
49038 swig_obj[0] = args;
49039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49040 if (!SWIG_IsOK(res1)) {
49041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49042 }
49043 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49044 {
49045 PyThreadState* __tstate = wxPyBeginAllowThreads();
49046 result = (bool)(arg1)->IsSizer();
49047 wxPyEndAllowThreads(__tstate);
49048 if (PyErr_Occurred()) SWIG_fail;
49049 }
49050 {
49051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49052 }
49053 return resultobj;
49054 fail:
49055 return NULL;
49056 }
49057
49058
49059 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49060 PyObject *resultobj = 0;
49061 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49062 bool result;
49063 void *argp1 = 0 ;
49064 int res1 = 0 ;
49065 PyObject *swig_obj[1] ;
49066
49067 if (!args) SWIG_fail;
49068 swig_obj[0] = args;
49069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49070 if (!SWIG_IsOK(res1)) {
49071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49072 }
49073 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49074 {
49075 PyThreadState* __tstate = wxPyBeginAllowThreads();
49076 result = (bool)(arg1)->IsSpacer();
49077 wxPyEndAllowThreads(__tstate);
49078 if (PyErr_Occurred()) SWIG_fail;
49079 }
49080 {
49081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49082 }
49083 return resultobj;
49084 fail:
49085 return NULL;
49086 }
49087
49088
49089 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49090 PyObject *resultobj = 0;
49091 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49092 int arg2 ;
49093 void *argp1 = 0 ;
49094 int res1 = 0 ;
49095 int val2 ;
49096 int ecode2 = 0 ;
49097 PyObject * obj0 = 0 ;
49098 PyObject * obj1 = 0 ;
49099 char * kwnames[] = {
49100 (char *) "self",(char *) "proportion", NULL
49101 };
49102
49103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
49104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49105 if (!SWIG_IsOK(res1)) {
49106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49107 }
49108 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49109 ecode2 = SWIG_AsVal_int(obj1, &val2);
49110 if (!SWIG_IsOK(ecode2)) {
49111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
49112 }
49113 arg2 = static_cast< int >(val2);
49114 {
49115 PyThreadState* __tstate = wxPyBeginAllowThreads();
49116 (arg1)->SetProportion(arg2);
49117 wxPyEndAllowThreads(__tstate);
49118 if (PyErr_Occurred()) SWIG_fail;
49119 }
49120 resultobj = SWIG_Py_Void();
49121 return resultobj;
49122 fail:
49123 return NULL;
49124 }
49125
49126
49127 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49128 PyObject *resultobj = 0;
49129 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49130 int result;
49131 void *argp1 = 0 ;
49132 int res1 = 0 ;
49133 PyObject *swig_obj[1] ;
49134
49135 if (!args) SWIG_fail;
49136 swig_obj[0] = args;
49137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49138 if (!SWIG_IsOK(res1)) {
49139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49140 }
49141 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49142 {
49143 PyThreadState* __tstate = wxPyBeginAllowThreads();
49144 result = (int)(arg1)->GetProportion();
49145 wxPyEndAllowThreads(__tstate);
49146 if (PyErr_Occurred()) SWIG_fail;
49147 }
49148 resultobj = SWIG_From_int(static_cast< int >(result));
49149 return resultobj;
49150 fail:
49151 return NULL;
49152 }
49153
49154
49155 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49156 PyObject *resultobj = 0;
49157 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49158 int arg2 ;
49159 void *argp1 = 0 ;
49160 int res1 = 0 ;
49161 int val2 ;
49162 int ecode2 = 0 ;
49163 PyObject * obj0 = 0 ;
49164 PyObject * obj1 = 0 ;
49165 char * kwnames[] = {
49166 (char *) "self",(char *) "flag", NULL
49167 };
49168
49169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
49170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49171 if (!SWIG_IsOK(res1)) {
49172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49173 }
49174 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49175 ecode2 = SWIG_AsVal_int(obj1, &val2);
49176 if (!SWIG_IsOK(ecode2)) {
49177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
49178 }
49179 arg2 = static_cast< int >(val2);
49180 {
49181 PyThreadState* __tstate = wxPyBeginAllowThreads();
49182 (arg1)->SetFlag(arg2);
49183 wxPyEndAllowThreads(__tstate);
49184 if (PyErr_Occurred()) SWIG_fail;
49185 }
49186 resultobj = SWIG_Py_Void();
49187 return resultobj;
49188 fail:
49189 return NULL;
49190 }
49191
49192
49193 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49194 PyObject *resultobj = 0;
49195 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49196 int result;
49197 void *argp1 = 0 ;
49198 int res1 = 0 ;
49199 PyObject *swig_obj[1] ;
49200
49201 if (!args) SWIG_fail;
49202 swig_obj[0] = args;
49203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49204 if (!SWIG_IsOK(res1)) {
49205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49206 }
49207 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49208 {
49209 PyThreadState* __tstate = wxPyBeginAllowThreads();
49210 result = (int)(arg1)->GetFlag();
49211 wxPyEndAllowThreads(__tstate);
49212 if (PyErr_Occurred()) SWIG_fail;
49213 }
49214 resultobj = SWIG_From_int(static_cast< int >(result));
49215 return resultobj;
49216 fail:
49217 return NULL;
49218 }
49219
49220
49221 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49222 PyObject *resultobj = 0;
49223 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49224 int arg2 ;
49225 void *argp1 = 0 ;
49226 int res1 = 0 ;
49227 int val2 ;
49228 int ecode2 = 0 ;
49229 PyObject * obj0 = 0 ;
49230 PyObject * obj1 = 0 ;
49231 char * kwnames[] = {
49232 (char *) "self",(char *) "border", NULL
49233 };
49234
49235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49237 if (!SWIG_IsOK(res1)) {
49238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49239 }
49240 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49241 ecode2 = SWIG_AsVal_int(obj1, &val2);
49242 if (!SWIG_IsOK(ecode2)) {
49243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
49244 }
49245 arg2 = static_cast< int >(val2);
49246 {
49247 PyThreadState* __tstate = wxPyBeginAllowThreads();
49248 (arg1)->SetBorder(arg2);
49249 wxPyEndAllowThreads(__tstate);
49250 if (PyErr_Occurred()) SWIG_fail;
49251 }
49252 resultobj = SWIG_Py_Void();
49253 return resultobj;
49254 fail:
49255 return NULL;
49256 }
49257
49258
49259 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49260 PyObject *resultobj = 0;
49261 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49262 int result;
49263 void *argp1 = 0 ;
49264 int res1 = 0 ;
49265 PyObject *swig_obj[1] ;
49266
49267 if (!args) SWIG_fail;
49268 swig_obj[0] = args;
49269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49270 if (!SWIG_IsOK(res1)) {
49271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49272 }
49273 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49274 {
49275 PyThreadState* __tstate = wxPyBeginAllowThreads();
49276 result = (int)(arg1)->GetBorder();
49277 wxPyEndAllowThreads(__tstate);
49278 if (PyErr_Occurred()) SWIG_fail;
49279 }
49280 resultobj = SWIG_From_int(static_cast< int >(result));
49281 return resultobj;
49282 fail:
49283 return NULL;
49284 }
49285
49286
49287 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49288 PyObject *resultobj = 0;
49289 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49290 wxWindow *result = 0 ;
49291 void *argp1 = 0 ;
49292 int res1 = 0 ;
49293 PyObject *swig_obj[1] ;
49294
49295 if (!args) SWIG_fail;
49296 swig_obj[0] = args;
49297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49298 if (!SWIG_IsOK(res1)) {
49299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49300 }
49301 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49302 {
49303 PyThreadState* __tstate = wxPyBeginAllowThreads();
49304 result = (wxWindow *)(arg1)->GetWindow();
49305 wxPyEndAllowThreads(__tstate);
49306 if (PyErr_Occurred()) SWIG_fail;
49307 }
49308 {
49309 resultobj = wxPyMake_wxObject(result, 0);
49310 }
49311 return resultobj;
49312 fail:
49313 return NULL;
49314 }
49315
49316
49317 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49318 PyObject *resultobj = 0;
49319 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49320 wxWindow *arg2 = (wxWindow *) 0 ;
49321 void *argp1 = 0 ;
49322 int res1 = 0 ;
49323 void *argp2 = 0 ;
49324 int res2 = 0 ;
49325 PyObject * obj0 = 0 ;
49326 PyObject * obj1 = 0 ;
49327 char * kwnames[] = {
49328 (char *) "self",(char *) "window", NULL
49329 };
49330
49331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
49332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49333 if (!SWIG_IsOK(res1)) {
49334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49335 }
49336 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49337 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49338 if (!SWIG_IsOK(res2)) {
49339 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
49340 }
49341 arg2 = reinterpret_cast< wxWindow * >(argp2);
49342 {
49343 PyThreadState* __tstate = wxPyBeginAllowThreads();
49344 (arg1)->SetWindow(arg2);
49345 wxPyEndAllowThreads(__tstate);
49346 if (PyErr_Occurred()) SWIG_fail;
49347 }
49348 resultobj = SWIG_Py_Void();
49349 return resultobj;
49350 fail:
49351 return NULL;
49352 }
49353
49354
49355 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49356 PyObject *resultobj = 0;
49357 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49358 wxSizer *result = 0 ;
49359 void *argp1 = 0 ;
49360 int res1 = 0 ;
49361 PyObject *swig_obj[1] ;
49362
49363 if (!args) SWIG_fail;
49364 swig_obj[0] = args;
49365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49366 if (!SWIG_IsOK(res1)) {
49367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49368 }
49369 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49370 {
49371 PyThreadState* __tstate = wxPyBeginAllowThreads();
49372 result = (wxSizer *)(arg1)->GetSizer();
49373 wxPyEndAllowThreads(__tstate);
49374 if (PyErr_Occurred()) SWIG_fail;
49375 }
49376 {
49377 resultobj = wxPyMake_wxObject(result, (bool)0);
49378 }
49379 return resultobj;
49380 fail:
49381 return NULL;
49382 }
49383
49384
49385 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49386 PyObject *resultobj = 0;
49387 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49388 wxSizer *arg2 = (wxSizer *) 0 ;
49389 void *argp1 = 0 ;
49390 int res1 = 0 ;
49391 int res2 = 0 ;
49392 PyObject * obj0 = 0 ;
49393 PyObject * obj1 = 0 ;
49394 char * kwnames[] = {
49395 (char *) "self",(char *) "sizer", NULL
49396 };
49397
49398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49400 if (!SWIG_IsOK(res1)) {
49401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49402 }
49403 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49404 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49405 if (!SWIG_IsOK(res2)) {
49406 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
49407 }
49408 {
49409 PyThreadState* __tstate = wxPyBeginAllowThreads();
49410 (arg1)->SetSizer(arg2);
49411 wxPyEndAllowThreads(__tstate);
49412 if (PyErr_Occurred()) SWIG_fail;
49413 }
49414 resultobj = SWIG_Py_Void();
49415 return resultobj;
49416 fail:
49417 return NULL;
49418 }
49419
49420
49421 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49422 PyObject *resultobj = 0;
49423 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49424 wxSize result;
49425 void *argp1 = 0 ;
49426 int res1 = 0 ;
49427 PyObject *swig_obj[1] ;
49428
49429 if (!args) SWIG_fail;
49430 swig_obj[0] = args;
49431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49432 if (!SWIG_IsOK(res1)) {
49433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49434 }
49435 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49436 {
49437 PyThreadState* __tstate = wxPyBeginAllowThreads();
49438 result = (arg1)->GetSpacer();
49439 wxPyEndAllowThreads(__tstate);
49440 if (PyErr_Occurred()) SWIG_fail;
49441 }
49442 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49443 return resultobj;
49444 fail:
49445 return NULL;
49446 }
49447
49448
49449 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49450 PyObject *resultobj = 0;
49451 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49452 wxSize *arg2 = 0 ;
49453 void *argp1 = 0 ;
49454 int res1 = 0 ;
49455 wxSize temp2 ;
49456 PyObject * obj0 = 0 ;
49457 PyObject * obj1 = 0 ;
49458 char * kwnames[] = {
49459 (char *) "self",(char *) "size", NULL
49460 };
49461
49462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
49463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49464 if (!SWIG_IsOK(res1)) {
49465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49466 }
49467 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49468 {
49469 arg2 = &temp2;
49470 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49471 }
49472 {
49473 PyThreadState* __tstate = wxPyBeginAllowThreads();
49474 (arg1)->SetSpacer((wxSize const &)*arg2);
49475 wxPyEndAllowThreads(__tstate);
49476 if (PyErr_Occurred()) SWIG_fail;
49477 }
49478 resultobj = SWIG_Py_Void();
49479 return resultobj;
49480 fail:
49481 return NULL;
49482 }
49483
49484
49485 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49486 PyObject *resultobj = 0;
49487 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49488 bool arg2 ;
49489 void *argp1 = 0 ;
49490 int res1 = 0 ;
49491 bool val2 ;
49492 int ecode2 = 0 ;
49493 PyObject * obj0 = 0 ;
49494 PyObject * obj1 = 0 ;
49495 char * kwnames[] = {
49496 (char *) "self",(char *) "show", NULL
49497 };
49498
49499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
49500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49501 if (!SWIG_IsOK(res1)) {
49502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49503 }
49504 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49505 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49506 if (!SWIG_IsOK(ecode2)) {
49507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
49508 }
49509 arg2 = static_cast< bool >(val2);
49510 {
49511 PyThreadState* __tstate = wxPyBeginAllowThreads();
49512 (arg1)->Show(arg2);
49513 wxPyEndAllowThreads(__tstate);
49514 if (PyErr_Occurred()) SWIG_fail;
49515 }
49516 resultobj = SWIG_Py_Void();
49517 return resultobj;
49518 fail:
49519 return NULL;
49520 }
49521
49522
49523 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49524 PyObject *resultobj = 0;
49525 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49526 bool result;
49527 void *argp1 = 0 ;
49528 int res1 = 0 ;
49529 PyObject *swig_obj[1] ;
49530
49531 if (!args) SWIG_fail;
49532 swig_obj[0] = args;
49533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49534 if (!SWIG_IsOK(res1)) {
49535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49536 }
49537 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49538 {
49539 PyThreadState* __tstate = wxPyBeginAllowThreads();
49540 result = (bool)(arg1)->IsShown();
49541 wxPyEndAllowThreads(__tstate);
49542 if (PyErr_Occurred()) SWIG_fail;
49543 }
49544 {
49545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49546 }
49547 return resultobj;
49548 fail:
49549 return NULL;
49550 }
49551
49552
49553 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49554 PyObject *resultobj = 0;
49555 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49556 wxPoint result;
49557 void *argp1 = 0 ;
49558 int res1 = 0 ;
49559 PyObject *swig_obj[1] ;
49560
49561 if (!args) SWIG_fail;
49562 swig_obj[0] = args;
49563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49564 if (!SWIG_IsOK(res1)) {
49565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49566 }
49567 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49568 {
49569 PyThreadState* __tstate = wxPyBeginAllowThreads();
49570 result = (arg1)->GetPosition();
49571 wxPyEndAllowThreads(__tstate);
49572 if (PyErr_Occurred()) SWIG_fail;
49573 }
49574 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
49575 return resultobj;
49576 fail:
49577 return NULL;
49578 }
49579
49580
49581 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49582 PyObject *resultobj = 0;
49583 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49584 PyObject *result = 0 ;
49585 void *argp1 = 0 ;
49586 int res1 = 0 ;
49587 PyObject *swig_obj[1] ;
49588
49589 if (!args) SWIG_fail;
49590 swig_obj[0] = args;
49591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49592 if (!SWIG_IsOK(res1)) {
49593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49594 }
49595 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49596 {
49597 PyThreadState* __tstate = wxPyBeginAllowThreads();
49598 result = (PyObject *)wxSizerItem_GetUserData(arg1);
49599 wxPyEndAllowThreads(__tstate);
49600 if (PyErr_Occurred()) SWIG_fail;
49601 }
49602 resultobj = result;
49603 return resultobj;
49604 fail:
49605 return NULL;
49606 }
49607
49608
49609 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49610 PyObject *resultobj = 0;
49611 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49612 PyObject *arg2 = (PyObject *) 0 ;
49613 void *argp1 = 0 ;
49614 int res1 = 0 ;
49615 PyObject * obj0 = 0 ;
49616 PyObject * obj1 = 0 ;
49617 char * kwnames[] = {
49618 (char *) "self",(char *) "userData", NULL
49619 };
49620
49621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
49622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49623 if (!SWIG_IsOK(res1)) {
49624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49625 }
49626 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49627 arg2 = obj1;
49628 {
49629 PyThreadState* __tstate = wxPyBeginAllowThreads();
49630 wxSizerItem_SetUserData(arg1,arg2);
49631 wxPyEndAllowThreads(__tstate);
49632 if (PyErr_Occurred()) SWIG_fail;
49633 }
49634 resultobj = SWIG_Py_Void();
49635 return resultobj;
49636 fail:
49637 return NULL;
49638 }
49639
49640
49641 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49642 PyObject *obj;
49643 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49644 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
49645 return SWIG_Py_Void();
49646 }
49647
49648 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49649 return SWIG_Python_InitShadowInstance(args);
49650 }
49651
49652 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49653 PyObject *resultobj = 0;
49654 wxSizer *arg1 = (wxSizer *) 0 ;
49655 void *argp1 = 0 ;
49656 int res1 = 0 ;
49657 PyObject *swig_obj[1] ;
49658
49659 if (!args) SWIG_fail;
49660 swig_obj[0] = args;
49661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49662 if (!SWIG_IsOK(res1)) {
49663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49664 }
49665 arg1 = reinterpret_cast< wxSizer * >(argp1);
49666 {
49667 PyThreadState* __tstate = wxPyBeginAllowThreads();
49668 delete arg1;
49669
49670 wxPyEndAllowThreads(__tstate);
49671 if (PyErr_Occurred()) SWIG_fail;
49672 }
49673 resultobj = SWIG_Py_Void();
49674 return resultobj;
49675 fail:
49676 return NULL;
49677 }
49678
49679
49680 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49681 PyObject *resultobj = 0;
49682 wxSizer *arg1 = (wxSizer *) 0 ;
49683 PyObject *arg2 = (PyObject *) 0 ;
49684 void *argp1 = 0 ;
49685 int res1 = 0 ;
49686 PyObject * obj0 = 0 ;
49687 PyObject * obj1 = 0 ;
49688 char * kwnames[] = {
49689 (char *) "self",(char *) "_self", NULL
49690 };
49691
49692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
49693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49694 if (!SWIG_IsOK(res1)) {
49695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
49696 }
49697 arg1 = reinterpret_cast< wxSizer * >(argp1);
49698 arg2 = obj1;
49699 {
49700 PyThreadState* __tstate = wxPyBeginAllowThreads();
49701 wxSizer__setOORInfo(arg1,arg2);
49702 wxPyEndAllowThreads(__tstate);
49703 if (PyErr_Occurred()) SWIG_fail;
49704 }
49705 resultobj = SWIG_Py_Void();
49706 return resultobj;
49707 fail:
49708 return NULL;
49709 }
49710
49711
49712 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49713 PyObject *resultobj = 0;
49714 wxSizer *arg1 = (wxSizer *) 0 ;
49715 PyObject *arg2 = (PyObject *) 0 ;
49716 int arg3 = (int) 0 ;
49717 int arg4 = (int) 0 ;
49718 int arg5 = (int) 0 ;
49719 PyObject *arg6 = (PyObject *) NULL ;
49720 wxSizerItem *result = 0 ;
49721 void *argp1 = 0 ;
49722 int res1 = 0 ;
49723 int val3 ;
49724 int ecode3 = 0 ;
49725 int val4 ;
49726 int ecode4 = 0 ;
49727 int val5 ;
49728 int ecode5 = 0 ;
49729 PyObject * obj0 = 0 ;
49730 PyObject * obj1 = 0 ;
49731 PyObject * obj2 = 0 ;
49732 PyObject * obj3 = 0 ;
49733 PyObject * obj4 = 0 ;
49734 PyObject * obj5 = 0 ;
49735 char * kwnames[] = {
49736 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49737 };
49738
49739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49741 if (!SWIG_IsOK(res1)) {
49742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
49743 }
49744 arg1 = reinterpret_cast< wxSizer * >(argp1);
49745 arg2 = obj1;
49746 if (obj2) {
49747 ecode3 = SWIG_AsVal_int(obj2, &val3);
49748 if (!SWIG_IsOK(ecode3)) {
49749 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
49750 }
49751 arg3 = static_cast< int >(val3);
49752 }
49753 if (obj3) {
49754 ecode4 = SWIG_AsVal_int(obj3, &val4);
49755 if (!SWIG_IsOK(ecode4)) {
49756 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
49757 }
49758 arg4 = static_cast< int >(val4);
49759 }
49760 if (obj4) {
49761 ecode5 = SWIG_AsVal_int(obj4, &val5);
49762 if (!SWIG_IsOK(ecode5)) {
49763 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
49764 }
49765 arg5 = static_cast< int >(val5);
49766 }
49767 if (obj5) {
49768 arg6 = obj5;
49769 }
49770 {
49771 PyThreadState* __tstate = wxPyBeginAllowThreads();
49772 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
49773 wxPyEndAllowThreads(__tstate);
49774 if (PyErr_Occurred()) SWIG_fail;
49775 }
49776 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49777 return resultobj;
49778 fail:
49779 return NULL;
49780 }
49781
49782
49783 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49784 PyObject *resultobj = 0;
49785 wxSizer *arg1 = (wxSizer *) 0 ;
49786 int arg2 ;
49787 PyObject *arg3 = (PyObject *) 0 ;
49788 int arg4 = (int) 0 ;
49789 int arg5 = (int) 0 ;
49790 int arg6 = (int) 0 ;
49791 PyObject *arg7 = (PyObject *) NULL ;
49792 wxSizerItem *result = 0 ;
49793 void *argp1 = 0 ;
49794 int res1 = 0 ;
49795 int val2 ;
49796 int ecode2 = 0 ;
49797 int val4 ;
49798 int ecode4 = 0 ;
49799 int val5 ;
49800 int ecode5 = 0 ;
49801 int val6 ;
49802 int ecode6 = 0 ;
49803 PyObject * obj0 = 0 ;
49804 PyObject * obj1 = 0 ;
49805 PyObject * obj2 = 0 ;
49806 PyObject * obj3 = 0 ;
49807 PyObject * obj4 = 0 ;
49808 PyObject * obj5 = 0 ;
49809 PyObject * obj6 = 0 ;
49810 char * kwnames[] = {
49811 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49812 };
49813
49814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49816 if (!SWIG_IsOK(res1)) {
49817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
49818 }
49819 arg1 = reinterpret_cast< wxSizer * >(argp1);
49820 ecode2 = SWIG_AsVal_int(obj1, &val2);
49821 if (!SWIG_IsOK(ecode2)) {
49822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
49823 }
49824 arg2 = static_cast< int >(val2);
49825 arg3 = obj2;
49826 if (obj3) {
49827 ecode4 = SWIG_AsVal_int(obj3, &val4);
49828 if (!SWIG_IsOK(ecode4)) {
49829 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
49830 }
49831 arg4 = static_cast< int >(val4);
49832 }
49833 if (obj4) {
49834 ecode5 = SWIG_AsVal_int(obj4, &val5);
49835 if (!SWIG_IsOK(ecode5)) {
49836 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
49837 }
49838 arg5 = static_cast< int >(val5);
49839 }
49840 if (obj5) {
49841 ecode6 = SWIG_AsVal_int(obj5, &val6);
49842 if (!SWIG_IsOK(ecode6)) {
49843 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
49844 }
49845 arg6 = static_cast< int >(val6);
49846 }
49847 if (obj6) {
49848 arg7 = obj6;
49849 }
49850 {
49851 PyThreadState* __tstate = wxPyBeginAllowThreads();
49852 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
49853 wxPyEndAllowThreads(__tstate);
49854 if (PyErr_Occurred()) SWIG_fail;
49855 }
49856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49857 return resultobj;
49858 fail:
49859 return NULL;
49860 }
49861
49862
49863 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49864 PyObject *resultobj = 0;
49865 wxSizer *arg1 = (wxSizer *) 0 ;
49866 PyObject *arg2 = (PyObject *) 0 ;
49867 int arg3 = (int) 0 ;
49868 int arg4 = (int) 0 ;
49869 int arg5 = (int) 0 ;
49870 PyObject *arg6 = (PyObject *) NULL ;
49871 wxSizerItem *result = 0 ;
49872 void *argp1 = 0 ;
49873 int res1 = 0 ;
49874 int val3 ;
49875 int ecode3 = 0 ;
49876 int val4 ;
49877 int ecode4 = 0 ;
49878 int val5 ;
49879 int ecode5 = 0 ;
49880 PyObject * obj0 = 0 ;
49881 PyObject * obj1 = 0 ;
49882 PyObject * obj2 = 0 ;
49883 PyObject * obj3 = 0 ;
49884 PyObject * obj4 = 0 ;
49885 PyObject * obj5 = 0 ;
49886 char * kwnames[] = {
49887 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49888 };
49889
49890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49892 if (!SWIG_IsOK(res1)) {
49893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
49894 }
49895 arg1 = reinterpret_cast< wxSizer * >(argp1);
49896 arg2 = obj1;
49897 if (obj2) {
49898 ecode3 = SWIG_AsVal_int(obj2, &val3);
49899 if (!SWIG_IsOK(ecode3)) {
49900 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
49901 }
49902 arg3 = static_cast< int >(val3);
49903 }
49904 if (obj3) {
49905 ecode4 = SWIG_AsVal_int(obj3, &val4);
49906 if (!SWIG_IsOK(ecode4)) {
49907 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
49908 }
49909 arg4 = static_cast< int >(val4);
49910 }
49911 if (obj4) {
49912 ecode5 = SWIG_AsVal_int(obj4, &val5);
49913 if (!SWIG_IsOK(ecode5)) {
49914 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
49915 }
49916 arg5 = static_cast< int >(val5);
49917 }
49918 if (obj5) {
49919 arg6 = obj5;
49920 }
49921 {
49922 PyThreadState* __tstate = wxPyBeginAllowThreads();
49923 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
49924 wxPyEndAllowThreads(__tstate);
49925 if (PyErr_Occurred()) SWIG_fail;
49926 }
49927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49928 return resultobj;
49929 fail:
49930 return NULL;
49931 }
49932
49933
49934 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49935 PyObject *resultobj = 0;
49936 wxSizer *arg1 = (wxSizer *) 0 ;
49937 PyObject *arg2 = (PyObject *) 0 ;
49938 bool result;
49939 void *argp1 = 0 ;
49940 int res1 = 0 ;
49941 PyObject * obj0 = 0 ;
49942 PyObject * obj1 = 0 ;
49943 char * kwnames[] = {
49944 (char *) "self",(char *) "item", NULL
49945 };
49946
49947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
49948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49949 if (!SWIG_IsOK(res1)) {
49950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
49951 }
49952 arg1 = reinterpret_cast< wxSizer * >(argp1);
49953 arg2 = obj1;
49954 {
49955 PyThreadState* __tstate = wxPyBeginAllowThreads();
49956 result = (bool)wxSizer_Remove(arg1,arg2);
49957 wxPyEndAllowThreads(__tstate);
49958 if (PyErr_Occurred()) SWIG_fail;
49959 }
49960 {
49961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49962 }
49963 return resultobj;
49964 fail:
49965 return NULL;
49966 }
49967
49968
49969 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49970 PyObject *resultobj = 0;
49971 wxSizer *arg1 = (wxSizer *) 0 ;
49972 PyObject *arg2 = (PyObject *) 0 ;
49973 bool result;
49974 void *argp1 = 0 ;
49975 int res1 = 0 ;
49976 PyObject * obj0 = 0 ;
49977 PyObject * obj1 = 0 ;
49978 char * kwnames[] = {
49979 (char *) "self",(char *) "item", NULL
49980 };
49981
49982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
49983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49984 if (!SWIG_IsOK(res1)) {
49985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
49986 }
49987 arg1 = reinterpret_cast< wxSizer * >(argp1);
49988 arg2 = obj1;
49989 {
49990 PyThreadState* __tstate = wxPyBeginAllowThreads();
49991 result = (bool)wxSizer_Detach(arg1,arg2);
49992 wxPyEndAllowThreads(__tstate);
49993 if (PyErr_Occurred()) SWIG_fail;
49994 }
49995 {
49996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49997 }
49998 return resultobj;
49999 fail:
50000 return NULL;
50001 }
50002
50003
50004 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50005 PyObject *resultobj = 0;
50006 wxSizer *arg1 = (wxSizer *) 0 ;
50007 PyObject *arg2 = (PyObject *) 0 ;
50008 wxSizerItem *result = 0 ;
50009 void *argp1 = 0 ;
50010 int res1 = 0 ;
50011 PyObject * obj0 = 0 ;
50012 PyObject * obj1 = 0 ;
50013 char * kwnames[] = {
50014 (char *) "self",(char *) "item", NULL
50015 };
50016
50017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
50018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50019 if (!SWIG_IsOK(res1)) {
50020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50021 }
50022 arg1 = reinterpret_cast< wxSizer * >(argp1);
50023 arg2 = obj1;
50024 {
50025 PyThreadState* __tstate = wxPyBeginAllowThreads();
50026 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
50027 wxPyEndAllowThreads(__tstate);
50028 if (PyErr_Occurred()) SWIG_fail;
50029 }
50030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50031 return resultobj;
50032 fail:
50033 return NULL;
50034 }
50035
50036
50037 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50038 PyObject *resultobj = 0;
50039 wxSizer *arg1 = (wxSizer *) 0 ;
50040 PyObject *arg2 = (PyObject *) 0 ;
50041 wxSize *arg3 = 0 ;
50042 void *argp1 = 0 ;
50043 int res1 = 0 ;
50044 wxSize temp3 ;
50045 PyObject * obj0 = 0 ;
50046 PyObject * obj1 = 0 ;
50047 PyObject * obj2 = 0 ;
50048 char * kwnames[] = {
50049 (char *) "self",(char *) "item",(char *) "size", NULL
50050 };
50051
50052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50054 if (!SWIG_IsOK(res1)) {
50055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50056 }
50057 arg1 = reinterpret_cast< wxSizer * >(argp1);
50058 arg2 = obj1;
50059 {
50060 arg3 = &temp3;
50061 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50062 }
50063 {
50064 PyThreadState* __tstate = wxPyBeginAllowThreads();
50065 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
50066 wxPyEndAllowThreads(__tstate);
50067 if (PyErr_Occurred()) SWIG_fail;
50068 }
50069 resultobj = SWIG_Py_Void();
50070 return resultobj;
50071 fail:
50072 return NULL;
50073 }
50074
50075
50076 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50077 PyObject *resultobj = 0;
50078 wxSizer *arg1 = (wxSizer *) 0 ;
50079 wxWindow *arg2 = (wxWindow *) 0 ;
50080 wxWindow *arg3 = (wxWindow *) 0 ;
50081 bool arg4 = (bool) false ;
50082 bool result;
50083 void *argp1 = 0 ;
50084 int res1 = 0 ;
50085 void *argp2 = 0 ;
50086 int res2 = 0 ;
50087 void *argp3 = 0 ;
50088 int res3 = 0 ;
50089 bool val4 ;
50090 int ecode4 = 0 ;
50091 PyObject * obj0 = 0 ;
50092 PyObject * obj1 = 0 ;
50093 PyObject * obj2 = 0 ;
50094 PyObject * obj3 = 0 ;
50095 char * kwnames[] = {
50096 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
50097 };
50098
50099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50101 if (!SWIG_IsOK(res1)) {
50102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
50103 }
50104 arg1 = reinterpret_cast< wxSizer * >(argp1);
50105 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50106 if (!SWIG_IsOK(res2)) {
50107 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
50108 }
50109 arg2 = reinterpret_cast< wxWindow * >(argp2);
50110 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50111 if (!SWIG_IsOK(res3)) {
50112 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
50113 }
50114 arg3 = reinterpret_cast< wxWindow * >(argp3);
50115 if (obj3) {
50116 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50117 if (!SWIG_IsOK(ecode4)) {
50118 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
50119 }
50120 arg4 = static_cast< bool >(val4);
50121 }
50122 {
50123 PyThreadState* __tstate = wxPyBeginAllowThreads();
50124 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50125 wxPyEndAllowThreads(__tstate);
50126 if (PyErr_Occurred()) SWIG_fail;
50127 }
50128 {
50129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50130 }
50131 return resultobj;
50132 fail:
50133 return NULL;
50134 }
50135
50136
50137 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50138 PyObject *resultobj = 0;
50139 wxSizer *arg1 = (wxSizer *) 0 ;
50140 wxSizer *arg2 = (wxSizer *) 0 ;
50141 wxSizer *arg3 = (wxSizer *) 0 ;
50142 bool arg4 = (bool) false ;
50143 bool result;
50144 void *argp1 = 0 ;
50145 int res1 = 0 ;
50146 void *argp2 = 0 ;
50147 int res2 = 0 ;
50148 void *argp3 = 0 ;
50149 int res3 = 0 ;
50150 bool val4 ;
50151 int ecode4 = 0 ;
50152 PyObject * obj0 = 0 ;
50153 PyObject * obj1 = 0 ;
50154 PyObject * obj2 = 0 ;
50155 PyObject * obj3 = 0 ;
50156 char * kwnames[] = {
50157 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
50158 };
50159
50160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50162 if (!SWIG_IsOK(res1)) {
50163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50164 }
50165 arg1 = reinterpret_cast< wxSizer * >(argp1);
50166 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50167 if (!SWIG_IsOK(res2)) {
50168 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50169 }
50170 arg2 = reinterpret_cast< wxSizer * >(argp2);
50171 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
50172 if (!SWIG_IsOK(res3)) {
50173 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
50174 }
50175 arg3 = reinterpret_cast< wxSizer * >(argp3);
50176 if (obj3) {
50177 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50178 if (!SWIG_IsOK(ecode4)) {
50179 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
50180 }
50181 arg4 = static_cast< bool >(val4);
50182 }
50183 {
50184 PyThreadState* __tstate = wxPyBeginAllowThreads();
50185 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50186 wxPyEndAllowThreads(__tstate);
50187 if (PyErr_Occurred()) SWIG_fail;
50188 }
50189 {
50190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50191 }
50192 return resultobj;
50193 fail:
50194 return NULL;
50195 }
50196
50197
50198 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50199 PyObject *resultobj = 0;
50200 wxSizer *arg1 = (wxSizer *) 0 ;
50201 size_t arg2 ;
50202 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50203 bool result;
50204 void *argp1 = 0 ;
50205 int res1 = 0 ;
50206 size_t val2 ;
50207 int ecode2 = 0 ;
50208 void *argp3 = 0 ;
50209 int res3 = 0 ;
50210 PyObject * obj0 = 0 ;
50211 PyObject * obj1 = 0 ;
50212 PyObject * obj2 = 0 ;
50213 char * kwnames[] = {
50214 (char *) "self",(char *) "index",(char *) "newitem", NULL
50215 };
50216
50217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50219 if (!SWIG_IsOK(res1)) {
50220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50221 }
50222 arg1 = reinterpret_cast< wxSizer * >(argp1);
50223 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50224 if (!SWIG_IsOK(ecode2)) {
50225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
50226 }
50227 arg2 = static_cast< size_t >(val2);
50228 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50229 if (!SWIG_IsOK(res3)) {
50230 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50231 }
50232 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
50233 {
50234 PyThreadState* __tstate = wxPyBeginAllowThreads();
50235 result = (bool)(arg1)->Replace(arg2,arg3);
50236 wxPyEndAllowThreads(__tstate);
50237 if (PyErr_Occurred()) SWIG_fail;
50238 }
50239 {
50240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50241 }
50242 return resultobj;
50243 fail:
50244 return NULL;
50245 }
50246
50247
50248 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50249 PyObject *resultobj = 0;
50250 wxSizer *arg1 = (wxSizer *) 0 ;
50251 wxWindow *arg2 = (wxWindow *) 0 ;
50252 void *argp1 = 0 ;
50253 int res1 = 0 ;
50254 void *argp2 = 0 ;
50255 int res2 = 0 ;
50256 PyObject * obj0 = 0 ;
50257 PyObject * obj1 = 0 ;
50258 char * kwnames[] = {
50259 (char *) "self",(char *) "window", NULL
50260 };
50261
50262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50264 if (!SWIG_IsOK(res1)) {
50265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
50266 }
50267 arg1 = reinterpret_cast< wxSizer * >(argp1);
50268 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50269 if (!SWIG_IsOK(res2)) {
50270 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50271 }
50272 arg2 = reinterpret_cast< wxWindow * >(argp2);
50273 {
50274 PyThreadState* __tstate = wxPyBeginAllowThreads();
50275 (arg1)->SetContainingWindow(arg2);
50276 wxPyEndAllowThreads(__tstate);
50277 if (PyErr_Occurred()) SWIG_fail;
50278 }
50279 resultobj = SWIG_Py_Void();
50280 return resultobj;
50281 fail:
50282 return NULL;
50283 }
50284
50285
50286 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50287 PyObject *resultobj = 0;
50288 wxSizer *arg1 = (wxSizer *) 0 ;
50289 wxWindow *result = 0 ;
50290 void *argp1 = 0 ;
50291 int res1 = 0 ;
50292 PyObject *swig_obj[1] ;
50293
50294 if (!args) SWIG_fail;
50295 swig_obj[0] = args;
50296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50297 if (!SWIG_IsOK(res1)) {
50298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
50299 }
50300 arg1 = reinterpret_cast< wxSizer * >(argp1);
50301 {
50302 PyThreadState* __tstate = wxPyBeginAllowThreads();
50303 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
50304 wxPyEndAllowThreads(__tstate);
50305 if (PyErr_Occurred()) SWIG_fail;
50306 }
50307 {
50308 resultobj = wxPyMake_wxObject(result, 0);
50309 }
50310 return resultobj;
50311 fail:
50312 return NULL;
50313 }
50314
50315
50316 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50317 PyObject *resultobj = 0;
50318 wxSizer *arg1 = (wxSizer *) 0 ;
50319 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50320 wxSizerItem *result = 0 ;
50321 void *argp1 = 0 ;
50322 int res1 = 0 ;
50323 int res2 = 0 ;
50324 PyObject * obj0 = 0 ;
50325 PyObject * obj1 = 0 ;
50326 char * kwnames[] = {
50327 (char *) "self",(char *) "item", NULL
50328 };
50329
50330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50332 if (!SWIG_IsOK(res1)) {
50333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50334 }
50335 arg1 = reinterpret_cast< wxSizer * >(argp1);
50336 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50337 if (!SWIG_IsOK(res2)) {
50338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50339 }
50340 {
50341 PyThreadState* __tstate = wxPyBeginAllowThreads();
50342 result = (wxSizerItem *)(arg1)->Add(arg2);
50343 wxPyEndAllowThreads(__tstate);
50344 if (PyErr_Occurred()) SWIG_fail;
50345 }
50346 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50347 return resultobj;
50348 fail:
50349 return NULL;
50350 }
50351
50352
50353 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50354 PyObject *resultobj = 0;
50355 wxSizer *arg1 = (wxSizer *) 0 ;
50356 size_t arg2 ;
50357 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50358 wxSizerItem *result = 0 ;
50359 void *argp1 = 0 ;
50360 int res1 = 0 ;
50361 size_t val2 ;
50362 int ecode2 = 0 ;
50363 int res3 = 0 ;
50364 PyObject * obj0 = 0 ;
50365 PyObject * obj1 = 0 ;
50366 PyObject * obj2 = 0 ;
50367 char * kwnames[] = {
50368 (char *) "self",(char *) "index",(char *) "item", NULL
50369 };
50370
50371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50373 if (!SWIG_IsOK(res1)) {
50374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50375 }
50376 arg1 = reinterpret_cast< wxSizer * >(argp1);
50377 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50378 if (!SWIG_IsOK(ecode2)) {
50379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
50380 }
50381 arg2 = static_cast< size_t >(val2);
50382 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50383 if (!SWIG_IsOK(res3)) {
50384 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50385 }
50386 {
50387 PyThreadState* __tstate = wxPyBeginAllowThreads();
50388 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
50389 wxPyEndAllowThreads(__tstate);
50390 if (PyErr_Occurred()) SWIG_fail;
50391 }
50392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50393 return resultobj;
50394 fail:
50395 return NULL;
50396 }
50397
50398
50399 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50400 PyObject *resultobj = 0;
50401 wxSizer *arg1 = (wxSizer *) 0 ;
50402 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50403 wxSizerItem *result = 0 ;
50404 void *argp1 = 0 ;
50405 int res1 = 0 ;
50406 int res2 = 0 ;
50407 PyObject * obj0 = 0 ;
50408 PyObject * obj1 = 0 ;
50409 char * kwnames[] = {
50410 (char *) "self",(char *) "item", NULL
50411 };
50412
50413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
50414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50415 if (!SWIG_IsOK(res1)) {
50416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50417 }
50418 arg1 = reinterpret_cast< wxSizer * >(argp1);
50419 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50420 if (!SWIG_IsOK(res2)) {
50421 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50422 }
50423 {
50424 PyThreadState* __tstate = wxPyBeginAllowThreads();
50425 result = (wxSizerItem *)(arg1)->Prepend(arg2);
50426 wxPyEndAllowThreads(__tstate);
50427 if (PyErr_Occurred()) SWIG_fail;
50428 }
50429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50430 return resultobj;
50431 fail:
50432 return NULL;
50433 }
50434
50435
50436 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50437 PyObject *resultobj = 0;
50438 wxSizer *arg1 = (wxSizer *) 0 ;
50439 int arg2 ;
50440 int arg3 ;
50441 int arg4 ;
50442 int arg5 ;
50443 void *argp1 = 0 ;
50444 int res1 = 0 ;
50445 int val2 ;
50446 int ecode2 = 0 ;
50447 int val3 ;
50448 int ecode3 = 0 ;
50449 int val4 ;
50450 int ecode4 = 0 ;
50451 int val5 ;
50452 int ecode5 = 0 ;
50453 PyObject * obj0 = 0 ;
50454 PyObject * obj1 = 0 ;
50455 PyObject * obj2 = 0 ;
50456 PyObject * obj3 = 0 ;
50457 PyObject * obj4 = 0 ;
50458 char * kwnames[] = {
50459 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
50460 };
50461
50462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50464 if (!SWIG_IsOK(res1)) {
50465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
50466 }
50467 arg1 = reinterpret_cast< wxSizer * >(argp1);
50468 ecode2 = SWIG_AsVal_int(obj1, &val2);
50469 if (!SWIG_IsOK(ecode2)) {
50470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
50471 }
50472 arg2 = static_cast< int >(val2);
50473 ecode3 = SWIG_AsVal_int(obj2, &val3);
50474 if (!SWIG_IsOK(ecode3)) {
50475 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
50476 }
50477 arg3 = static_cast< int >(val3);
50478 ecode4 = SWIG_AsVal_int(obj3, &val4);
50479 if (!SWIG_IsOK(ecode4)) {
50480 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
50481 }
50482 arg4 = static_cast< int >(val4);
50483 ecode5 = SWIG_AsVal_int(obj4, &val5);
50484 if (!SWIG_IsOK(ecode5)) {
50485 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
50486 }
50487 arg5 = static_cast< int >(val5);
50488 {
50489 PyThreadState* __tstate = wxPyBeginAllowThreads();
50490 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
50491 wxPyEndAllowThreads(__tstate);
50492 if (PyErr_Occurred()) SWIG_fail;
50493 }
50494 resultobj = SWIG_Py_Void();
50495 return resultobj;
50496 fail:
50497 return NULL;
50498 }
50499
50500
50501 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50502 PyObject *resultobj = 0;
50503 wxSizer *arg1 = (wxSizer *) 0 ;
50504 wxSize *arg2 = 0 ;
50505 void *argp1 = 0 ;
50506 int res1 = 0 ;
50507 wxSize temp2 ;
50508 PyObject * obj0 = 0 ;
50509 PyObject * obj1 = 0 ;
50510 char * kwnames[] = {
50511 (char *) "self",(char *) "size", NULL
50512 };
50513
50514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
50515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50516 if (!SWIG_IsOK(res1)) {
50517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50518 }
50519 arg1 = reinterpret_cast< wxSizer * >(argp1);
50520 {
50521 arg2 = &temp2;
50522 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50523 }
50524 {
50525 PyThreadState* __tstate = wxPyBeginAllowThreads();
50526 (arg1)->SetMinSize((wxSize const &)*arg2);
50527 wxPyEndAllowThreads(__tstate);
50528 if (PyErr_Occurred()) SWIG_fail;
50529 }
50530 resultobj = SWIG_Py_Void();
50531 return resultobj;
50532 fail:
50533 return NULL;
50534 }
50535
50536
50537 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50538 PyObject *resultobj = 0;
50539 wxSizer *arg1 = (wxSizer *) 0 ;
50540 wxSize result;
50541 void *argp1 = 0 ;
50542 int res1 = 0 ;
50543 PyObject *swig_obj[1] ;
50544
50545 if (!args) SWIG_fail;
50546 swig_obj[0] = args;
50547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50548 if (!SWIG_IsOK(res1)) {
50549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50550 }
50551 arg1 = reinterpret_cast< wxSizer * >(argp1);
50552 {
50553 PyThreadState* __tstate = wxPyBeginAllowThreads();
50554 result = (arg1)->GetSize();
50555 wxPyEndAllowThreads(__tstate);
50556 if (PyErr_Occurred()) SWIG_fail;
50557 }
50558 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50559 return resultobj;
50560 fail:
50561 return NULL;
50562 }
50563
50564
50565 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50566 PyObject *resultobj = 0;
50567 wxSizer *arg1 = (wxSizer *) 0 ;
50568 wxPoint result;
50569 void *argp1 = 0 ;
50570 int res1 = 0 ;
50571 PyObject *swig_obj[1] ;
50572
50573 if (!args) SWIG_fail;
50574 swig_obj[0] = args;
50575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50576 if (!SWIG_IsOK(res1)) {
50577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
50578 }
50579 arg1 = reinterpret_cast< wxSizer * >(argp1);
50580 {
50581 PyThreadState* __tstate = wxPyBeginAllowThreads();
50582 result = (arg1)->GetPosition();
50583 wxPyEndAllowThreads(__tstate);
50584 if (PyErr_Occurred()) SWIG_fail;
50585 }
50586 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50587 return resultobj;
50588 fail:
50589 return NULL;
50590 }
50591
50592
50593 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50594 PyObject *resultobj = 0;
50595 wxSizer *arg1 = (wxSizer *) 0 ;
50596 wxSize result;
50597 void *argp1 = 0 ;
50598 int res1 = 0 ;
50599 PyObject *swig_obj[1] ;
50600
50601 if (!args) SWIG_fail;
50602 swig_obj[0] = args;
50603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50604 if (!SWIG_IsOK(res1)) {
50605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50606 }
50607 arg1 = reinterpret_cast< wxSizer * >(argp1);
50608 {
50609 PyThreadState* __tstate = wxPyBeginAllowThreads();
50610 result = (arg1)->GetMinSize();
50611 wxPyEndAllowThreads(__tstate);
50612 if (PyErr_Occurred()) SWIG_fail;
50613 }
50614 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50615 return resultobj;
50616 fail:
50617 return NULL;
50618 }
50619
50620
50621 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50622 PyObject *resultobj = 0;
50623 wxSizer *arg1 = (wxSizer *) 0 ;
50624 void *argp1 = 0 ;
50625 int res1 = 0 ;
50626 PyObject *swig_obj[1] ;
50627
50628 if (!args) SWIG_fail;
50629 swig_obj[0] = args;
50630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50631 if (!SWIG_IsOK(res1)) {
50632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
50633 }
50634 arg1 = reinterpret_cast< wxSizer * >(argp1);
50635 {
50636 PyThreadState* __tstate = wxPyBeginAllowThreads();
50637 (arg1)->RecalcSizes();
50638 wxPyEndAllowThreads(__tstate);
50639 if (PyErr_Occurred()) SWIG_fail;
50640 }
50641 resultobj = SWIG_Py_Void();
50642 return resultobj;
50643 fail:
50644 return NULL;
50645 }
50646
50647
50648 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50649 PyObject *resultobj = 0;
50650 wxSizer *arg1 = (wxSizer *) 0 ;
50651 wxSize result;
50652 void *argp1 = 0 ;
50653 int res1 = 0 ;
50654 PyObject *swig_obj[1] ;
50655
50656 if (!args) SWIG_fail;
50657 swig_obj[0] = args;
50658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50659 if (!SWIG_IsOK(res1)) {
50660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
50661 }
50662 arg1 = reinterpret_cast< wxSizer * >(argp1);
50663 {
50664 PyThreadState* __tstate = wxPyBeginAllowThreads();
50665 result = (arg1)->CalcMin();
50666 wxPyEndAllowThreads(__tstate);
50667 if (PyErr_Occurred()) SWIG_fail;
50668 }
50669 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50670 return resultobj;
50671 fail:
50672 return NULL;
50673 }
50674
50675
50676 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50677 PyObject *resultobj = 0;
50678 wxSizer *arg1 = (wxSizer *) 0 ;
50679 void *argp1 = 0 ;
50680 int res1 = 0 ;
50681 PyObject *swig_obj[1] ;
50682
50683 if (!args) SWIG_fail;
50684 swig_obj[0] = args;
50685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50686 if (!SWIG_IsOK(res1)) {
50687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
50688 }
50689 arg1 = reinterpret_cast< wxSizer * >(argp1);
50690 {
50691 PyThreadState* __tstate = wxPyBeginAllowThreads();
50692 (arg1)->Layout();
50693 wxPyEndAllowThreads(__tstate);
50694 if (PyErr_Occurred()) SWIG_fail;
50695 }
50696 resultobj = SWIG_Py_Void();
50697 return resultobj;
50698 fail:
50699 return NULL;
50700 }
50701
50702
50703 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50704 PyObject *resultobj = 0;
50705 wxSizer *arg1 = (wxSizer *) 0 ;
50706 wxWindow *arg2 = (wxWindow *) 0 ;
50707 wxSize result;
50708 void *argp1 = 0 ;
50709 int res1 = 0 ;
50710 void *argp2 = 0 ;
50711 int res2 = 0 ;
50712 PyObject * obj0 = 0 ;
50713 PyObject * obj1 = 0 ;
50714 char * kwnames[] = {
50715 (char *) "self",(char *) "window", NULL
50716 };
50717
50718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
50719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50720 if (!SWIG_IsOK(res1)) {
50721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
50722 }
50723 arg1 = reinterpret_cast< wxSizer * >(argp1);
50724 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50725 if (!SWIG_IsOK(res2)) {
50726 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
50727 }
50728 arg2 = reinterpret_cast< wxWindow * >(argp2);
50729 {
50730 PyThreadState* __tstate = wxPyBeginAllowThreads();
50731 result = (arg1)->Fit(arg2);
50732 wxPyEndAllowThreads(__tstate);
50733 if (PyErr_Occurred()) SWIG_fail;
50734 }
50735 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50736 return resultobj;
50737 fail:
50738 return NULL;
50739 }
50740
50741
50742 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50743 PyObject *resultobj = 0;
50744 wxSizer *arg1 = (wxSizer *) 0 ;
50745 wxWindow *arg2 = (wxWindow *) 0 ;
50746 void *argp1 = 0 ;
50747 int res1 = 0 ;
50748 void *argp2 = 0 ;
50749 int res2 = 0 ;
50750 PyObject * obj0 = 0 ;
50751 PyObject * obj1 = 0 ;
50752 char * kwnames[] = {
50753 (char *) "self",(char *) "window", NULL
50754 };
50755
50756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
50757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50758 if (!SWIG_IsOK(res1)) {
50759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
50760 }
50761 arg1 = reinterpret_cast< wxSizer * >(argp1);
50762 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50763 if (!SWIG_IsOK(res2)) {
50764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
50765 }
50766 arg2 = reinterpret_cast< wxWindow * >(argp2);
50767 {
50768 PyThreadState* __tstate = wxPyBeginAllowThreads();
50769 (arg1)->FitInside(arg2);
50770 wxPyEndAllowThreads(__tstate);
50771 if (PyErr_Occurred()) SWIG_fail;
50772 }
50773 resultobj = SWIG_Py_Void();
50774 return resultobj;
50775 fail:
50776 return NULL;
50777 }
50778
50779
50780 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50781 PyObject *resultobj = 0;
50782 wxSizer *arg1 = (wxSizer *) 0 ;
50783 wxWindow *arg2 = (wxWindow *) 0 ;
50784 void *argp1 = 0 ;
50785 int res1 = 0 ;
50786 void *argp2 = 0 ;
50787 int res2 = 0 ;
50788 PyObject * obj0 = 0 ;
50789 PyObject * obj1 = 0 ;
50790 char * kwnames[] = {
50791 (char *) "self",(char *) "window", NULL
50792 };
50793
50794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50796 if (!SWIG_IsOK(res1)) {
50797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50798 }
50799 arg1 = reinterpret_cast< wxSizer * >(argp1);
50800 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50801 if (!SWIG_IsOK(res2)) {
50802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50803 }
50804 arg2 = reinterpret_cast< wxWindow * >(argp2);
50805 {
50806 PyThreadState* __tstate = wxPyBeginAllowThreads();
50807 (arg1)->SetSizeHints(arg2);
50808 wxPyEndAllowThreads(__tstate);
50809 if (PyErr_Occurred()) SWIG_fail;
50810 }
50811 resultobj = SWIG_Py_Void();
50812 return resultobj;
50813 fail:
50814 return NULL;
50815 }
50816
50817
50818 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50819 PyObject *resultobj = 0;
50820 wxSizer *arg1 = (wxSizer *) 0 ;
50821 wxWindow *arg2 = (wxWindow *) 0 ;
50822 void *argp1 = 0 ;
50823 int res1 = 0 ;
50824 void *argp2 = 0 ;
50825 int res2 = 0 ;
50826 PyObject * obj0 = 0 ;
50827 PyObject * obj1 = 0 ;
50828 char * kwnames[] = {
50829 (char *) "self",(char *) "window", NULL
50830 };
50831
50832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50834 if (!SWIG_IsOK(res1)) {
50835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50836 }
50837 arg1 = reinterpret_cast< wxSizer * >(argp1);
50838 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50839 if (!SWIG_IsOK(res2)) {
50840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50841 }
50842 arg2 = reinterpret_cast< wxWindow * >(argp2);
50843 {
50844 PyThreadState* __tstate = wxPyBeginAllowThreads();
50845 (arg1)->SetVirtualSizeHints(arg2);
50846 wxPyEndAllowThreads(__tstate);
50847 if (PyErr_Occurred()) SWIG_fail;
50848 }
50849 resultobj = SWIG_Py_Void();
50850 return resultobj;
50851 fail:
50852 return NULL;
50853 }
50854
50855
50856 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50857 PyObject *resultobj = 0;
50858 wxSizer *arg1 = (wxSizer *) 0 ;
50859 bool arg2 = (bool) false ;
50860 void *argp1 = 0 ;
50861 int res1 = 0 ;
50862 bool val2 ;
50863 int ecode2 = 0 ;
50864 PyObject * obj0 = 0 ;
50865 PyObject * obj1 = 0 ;
50866 char * kwnames[] = {
50867 (char *) "self",(char *) "deleteWindows", NULL
50868 };
50869
50870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
50871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50872 if (!SWIG_IsOK(res1)) {
50873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
50874 }
50875 arg1 = reinterpret_cast< wxSizer * >(argp1);
50876 if (obj1) {
50877 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50878 if (!SWIG_IsOK(ecode2)) {
50879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
50880 }
50881 arg2 = static_cast< bool >(val2);
50882 }
50883 {
50884 PyThreadState* __tstate = wxPyBeginAllowThreads();
50885 (arg1)->Clear(arg2);
50886 wxPyEndAllowThreads(__tstate);
50887 if (PyErr_Occurred()) SWIG_fail;
50888 }
50889 resultobj = SWIG_Py_Void();
50890 return resultobj;
50891 fail:
50892 return NULL;
50893 }
50894
50895
50896 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50897 PyObject *resultobj = 0;
50898 wxSizer *arg1 = (wxSizer *) 0 ;
50899 void *argp1 = 0 ;
50900 int res1 = 0 ;
50901 PyObject *swig_obj[1] ;
50902
50903 if (!args) SWIG_fail;
50904 swig_obj[0] = args;
50905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50906 if (!SWIG_IsOK(res1)) {
50907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
50908 }
50909 arg1 = reinterpret_cast< wxSizer * >(argp1);
50910 {
50911 PyThreadState* __tstate = wxPyBeginAllowThreads();
50912 (arg1)->DeleteWindows();
50913 wxPyEndAllowThreads(__tstate);
50914 if (PyErr_Occurred()) SWIG_fail;
50915 }
50916 resultobj = SWIG_Py_Void();
50917 return resultobj;
50918 fail:
50919 return NULL;
50920 }
50921
50922
50923 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50924 PyObject *resultobj = 0;
50925 wxSizer *arg1 = (wxSizer *) 0 ;
50926 PyObject *result = 0 ;
50927 void *argp1 = 0 ;
50928 int res1 = 0 ;
50929 PyObject *swig_obj[1] ;
50930
50931 if (!args) SWIG_fail;
50932 swig_obj[0] = args;
50933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50934 if (!SWIG_IsOK(res1)) {
50935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
50936 }
50937 arg1 = reinterpret_cast< wxSizer * >(argp1);
50938 {
50939 PyThreadState* __tstate = wxPyBeginAllowThreads();
50940 result = (PyObject *)wxSizer_GetChildren(arg1);
50941 wxPyEndAllowThreads(__tstate);
50942 if (PyErr_Occurred()) SWIG_fail;
50943 }
50944 resultobj = result;
50945 return resultobj;
50946 fail:
50947 return NULL;
50948 }
50949
50950
50951 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50952 PyObject *resultobj = 0;
50953 wxSizer *arg1 = (wxSizer *) 0 ;
50954 PyObject *arg2 = (PyObject *) 0 ;
50955 bool arg3 = (bool) true ;
50956 bool arg4 = (bool) false ;
50957 bool result;
50958 void *argp1 = 0 ;
50959 int res1 = 0 ;
50960 bool val3 ;
50961 int ecode3 = 0 ;
50962 bool val4 ;
50963 int ecode4 = 0 ;
50964 PyObject * obj0 = 0 ;
50965 PyObject * obj1 = 0 ;
50966 PyObject * obj2 = 0 ;
50967 PyObject * obj3 = 0 ;
50968 char * kwnames[] = {
50969 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
50970 };
50971
50972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50974 if (!SWIG_IsOK(res1)) {
50975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
50976 }
50977 arg1 = reinterpret_cast< wxSizer * >(argp1);
50978 arg2 = obj1;
50979 if (obj2) {
50980 ecode3 = SWIG_AsVal_bool(obj2, &val3);
50981 if (!SWIG_IsOK(ecode3)) {
50982 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
50983 }
50984 arg3 = static_cast< bool >(val3);
50985 }
50986 if (obj3) {
50987 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50988 if (!SWIG_IsOK(ecode4)) {
50989 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
50990 }
50991 arg4 = static_cast< bool >(val4);
50992 }
50993 {
50994 PyThreadState* __tstate = wxPyBeginAllowThreads();
50995 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
50996 wxPyEndAllowThreads(__tstate);
50997 if (PyErr_Occurred()) SWIG_fail;
50998 }
50999 {
51000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51001 }
51002 return resultobj;
51003 fail:
51004 return NULL;
51005 }
51006
51007
51008 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51009 PyObject *resultobj = 0;
51010 wxSizer *arg1 = (wxSizer *) 0 ;
51011 PyObject *arg2 = (PyObject *) 0 ;
51012 bool result;
51013 void *argp1 = 0 ;
51014 int res1 = 0 ;
51015 PyObject * obj0 = 0 ;
51016 PyObject * obj1 = 0 ;
51017 char * kwnames[] = {
51018 (char *) "self",(char *) "item", NULL
51019 };
51020
51021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
51022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51023 if (!SWIG_IsOK(res1)) {
51024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
51025 }
51026 arg1 = reinterpret_cast< wxSizer * >(argp1);
51027 arg2 = obj1;
51028 {
51029 PyThreadState* __tstate = wxPyBeginAllowThreads();
51030 result = (bool)wxSizer_IsShown(arg1,arg2);
51031 wxPyEndAllowThreads(__tstate);
51032 if (PyErr_Occurred()) SWIG_fail;
51033 }
51034 {
51035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51036 }
51037 return resultobj;
51038 fail:
51039 return NULL;
51040 }
51041
51042
51043 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51044 PyObject *resultobj = 0;
51045 wxSizer *arg1 = (wxSizer *) 0 ;
51046 bool arg2 ;
51047 void *argp1 = 0 ;
51048 int res1 = 0 ;
51049 bool val2 ;
51050 int ecode2 = 0 ;
51051 PyObject * obj0 = 0 ;
51052 PyObject * obj1 = 0 ;
51053 char * kwnames[] = {
51054 (char *) "self",(char *) "show", NULL
51055 };
51056
51057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
51058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51059 if (!SWIG_IsOK(res1)) {
51060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
51061 }
51062 arg1 = reinterpret_cast< wxSizer * >(argp1);
51063 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51064 if (!SWIG_IsOK(ecode2)) {
51065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
51066 }
51067 arg2 = static_cast< bool >(val2);
51068 {
51069 PyThreadState* __tstate = wxPyBeginAllowThreads();
51070 (arg1)->ShowItems(arg2);
51071 wxPyEndAllowThreads(__tstate);
51072 if (PyErr_Occurred()) SWIG_fail;
51073 }
51074 resultobj = SWIG_Py_Void();
51075 return resultobj;
51076 fail:
51077 return NULL;
51078 }
51079
51080
51081 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51082 PyObject *obj;
51083 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51084 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
51085 return SWIG_Py_Void();
51086 }
51087
51088 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51089 PyObject *resultobj = 0;
51090 wxPySizer *result = 0 ;
51091
51092 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
51093 {
51094 PyThreadState* __tstate = wxPyBeginAllowThreads();
51095 result = (wxPySizer *)new wxPySizer();
51096 wxPyEndAllowThreads(__tstate);
51097 if (PyErr_Occurred()) SWIG_fail;
51098 }
51099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
51100 return resultobj;
51101 fail:
51102 return NULL;
51103 }
51104
51105
51106 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51107 PyObject *resultobj = 0;
51108 wxPySizer *arg1 = (wxPySizer *) 0 ;
51109 PyObject *arg2 = (PyObject *) 0 ;
51110 PyObject *arg3 = (PyObject *) 0 ;
51111 void *argp1 = 0 ;
51112 int res1 = 0 ;
51113 PyObject * obj0 = 0 ;
51114 PyObject * obj1 = 0 ;
51115 PyObject * obj2 = 0 ;
51116 char * kwnames[] = {
51117 (char *) "self",(char *) "self",(char *) "_class", NULL
51118 };
51119
51120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
51122 if (!SWIG_IsOK(res1)) {
51123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
51124 }
51125 arg1 = reinterpret_cast< wxPySizer * >(argp1);
51126 arg2 = obj1;
51127 arg3 = obj2;
51128 {
51129 PyThreadState* __tstate = wxPyBeginAllowThreads();
51130 (arg1)->_setCallbackInfo(arg2,arg3);
51131 wxPyEndAllowThreads(__tstate);
51132 if (PyErr_Occurred()) SWIG_fail;
51133 }
51134 resultobj = SWIG_Py_Void();
51135 return resultobj;
51136 fail:
51137 return NULL;
51138 }
51139
51140
51141 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51142 PyObject *obj;
51143 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51144 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
51145 return SWIG_Py_Void();
51146 }
51147
51148 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51149 return SWIG_Python_InitShadowInstance(args);
51150 }
51151
51152 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51153 PyObject *resultobj = 0;
51154 int arg1 = (int) wxHORIZONTAL ;
51155 wxBoxSizer *result = 0 ;
51156 int val1 ;
51157 int ecode1 = 0 ;
51158 PyObject * obj0 = 0 ;
51159 char * kwnames[] = {
51160 (char *) "orient", NULL
51161 };
51162
51163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
51164 if (obj0) {
51165 ecode1 = SWIG_AsVal_int(obj0, &val1);
51166 if (!SWIG_IsOK(ecode1)) {
51167 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
51168 }
51169 arg1 = static_cast< int >(val1);
51170 }
51171 {
51172 PyThreadState* __tstate = wxPyBeginAllowThreads();
51173 result = (wxBoxSizer *)new wxBoxSizer(arg1);
51174 wxPyEndAllowThreads(__tstate);
51175 if (PyErr_Occurred()) SWIG_fail;
51176 }
51177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
51178 return resultobj;
51179 fail:
51180 return NULL;
51181 }
51182
51183
51184 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51185 PyObject *resultobj = 0;
51186 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51187 int result;
51188 void *argp1 = 0 ;
51189 int res1 = 0 ;
51190 PyObject *swig_obj[1] ;
51191
51192 if (!args) SWIG_fail;
51193 swig_obj[0] = args;
51194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51195 if (!SWIG_IsOK(res1)) {
51196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51197 }
51198 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51199 {
51200 PyThreadState* __tstate = wxPyBeginAllowThreads();
51201 result = (int)(arg1)->GetOrientation();
51202 wxPyEndAllowThreads(__tstate);
51203 if (PyErr_Occurred()) SWIG_fail;
51204 }
51205 resultobj = SWIG_From_int(static_cast< int >(result));
51206 return resultobj;
51207 fail:
51208 return NULL;
51209 }
51210
51211
51212 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51213 PyObject *resultobj = 0;
51214 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51215 int arg2 ;
51216 void *argp1 = 0 ;
51217 int res1 = 0 ;
51218 int val2 ;
51219 int ecode2 = 0 ;
51220 PyObject * obj0 = 0 ;
51221 PyObject * obj1 = 0 ;
51222 char * kwnames[] = {
51223 (char *) "self",(char *) "orient", NULL
51224 };
51225
51226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
51227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51228 if (!SWIG_IsOK(res1)) {
51229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51230 }
51231 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51232 ecode2 = SWIG_AsVal_int(obj1, &val2);
51233 if (!SWIG_IsOK(ecode2)) {
51234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
51235 }
51236 arg2 = static_cast< int >(val2);
51237 {
51238 PyThreadState* __tstate = wxPyBeginAllowThreads();
51239 (arg1)->SetOrientation(arg2);
51240 wxPyEndAllowThreads(__tstate);
51241 if (PyErr_Occurred()) SWIG_fail;
51242 }
51243 resultobj = SWIG_Py_Void();
51244 return resultobj;
51245 fail:
51246 return NULL;
51247 }
51248
51249
51250 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51251 PyObject *obj;
51252 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51253 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
51254 return SWIG_Py_Void();
51255 }
51256
51257 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51258 return SWIG_Python_InitShadowInstance(args);
51259 }
51260
51261 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51262 PyObject *resultobj = 0;
51263 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
51264 int arg2 = (int) wxHORIZONTAL ;
51265 wxStaticBoxSizer *result = 0 ;
51266 void *argp1 = 0 ;
51267 int res1 = 0 ;
51268 int val2 ;
51269 int ecode2 = 0 ;
51270 PyObject * obj0 = 0 ;
51271 PyObject * obj1 = 0 ;
51272 char * kwnames[] = {
51273 (char *) "box",(char *) "orient", NULL
51274 };
51275
51276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
51278 if (!SWIG_IsOK(res1)) {
51279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
51280 }
51281 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
51282 if (obj1) {
51283 ecode2 = SWIG_AsVal_int(obj1, &val2);
51284 if (!SWIG_IsOK(ecode2)) {
51285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
51286 }
51287 arg2 = static_cast< int >(val2);
51288 }
51289 {
51290 PyThreadState* __tstate = wxPyBeginAllowThreads();
51291 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
51292 wxPyEndAllowThreads(__tstate);
51293 if (PyErr_Occurred()) SWIG_fail;
51294 }
51295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
51296 return resultobj;
51297 fail:
51298 return NULL;
51299 }
51300
51301
51302 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51303 PyObject *resultobj = 0;
51304 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
51305 wxStaticBox *result = 0 ;
51306 void *argp1 = 0 ;
51307 int res1 = 0 ;
51308 PyObject *swig_obj[1] ;
51309
51310 if (!args) SWIG_fail;
51311 swig_obj[0] = args;
51312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
51313 if (!SWIG_IsOK(res1)) {
51314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
51315 }
51316 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
51317 {
51318 PyThreadState* __tstate = wxPyBeginAllowThreads();
51319 result = (wxStaticBox *)(arg1)->GetStaticBox();
51320 wxPyEndAllowThreads(__tstate);
51321 if (PyErr_Occurred()) SWIG_fail;
51322 }
51323 {
51324 resultobj = wxPyMake_wxObject(result, (bool)0);
51325 }
51326 return resultobj;
51327 fail:
51328 return NULL;
51329 }
51330
51331
51332 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51333 PyObject *obj;
51334 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51335 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
51336 return SWIG_Py_Void();
51337 }
51338
51339 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51340 return SWIG_Python_InitShadowInstance(args);
51341 }
51342
51343 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51344 PyObject *resultobj = 0;
51345 int arg1 = (int) 1 ;
51346 int arg2 = (int) 0 ;
51347 int arg3 = (int) 0 ;
51348 int arg4 = (int) 0 ;
51349 wxGridSizer *result = 0 ;
51350 int val1 ;
51351 int ecode1 = 0 ;
51352 int val2 ;
51353 int ecode2 = 0 ;
51354 int val3 ;
51355 int ecode3 = 0 ;
51356 int val4 ;
51357 int ecode4 = 0 ;
51358 PyObject * obj0 = 0 ;
51359 PyObject * obj1 = 0 ;
51360 PyObject * obj2 = 0 ;
51361 PyObject * obj3 = 0 ;
51362 char * kwnames[] = {
51363 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51364 };
51365
51366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51367 if (obj0) {
51368 ecode1 = SWIG_AsVal_int(obj0, &val1);
51369 if (!SWIG_IsOK(ecode1)) {
51370 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
51371 }
51372 arg1 = static_cast< int >(val1);
51373 }
51374 if (obj1) {
51375 ecode2 = SWIG_AsVal_int(obj1, &val2);
51376 if (!SWIG_IsOK(ecode2)) {
51377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
51378 }
51379 arg2 = static_cast< int >(val2);
51380 }
51381 if (obj2) {
51382 ecode3 = SWIG_AsVal_int(obj2, &val3);
51383 if (!SWIG_IsOK(ecode3)) {
51384 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
51385 }
51386 arg3 = static_cast< int >(val3);
51387 }
51388 if (obj3) {
51389 ecode4 = SWIG_AsVal_int(obj3, &val4);
51390 if (!SWIG_IsOK(ecode4)) {
51391 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
51392 }
51393 arg4 = static_cast< int >(val4);
51394 }
51395 {
51396 PyThreadState* __tstate = wxPyBeginAllowThreads();
51397 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
51398 wxPyEndAllowThreads(__tstate);
51399 if (PyErr_Occurred()) SWIG_fail;
51400 }
51401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
51402 return resultobj;
51403 fail:
51404 return NULL;
51405 }
51406
51407
51408 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51409 PyObject *resultobj = 0;
51410 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51411 int arg2 ;
51412 void *argp1 = 0 ;
51413 int res1 = 0 ;
51414 int val2 ;
51415 int ecode2 = 0 ;
51416 PyObject * obj0 = 0 ;
51417 PyObject * obj1 = 0 ;
51418 char * kwnames[] = {
51419 (char *) "self",(char *) "cols", NULL
51420 };
51421
51422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
51423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51424 if (!SWIG_IsOK(res1)) {
51425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51426 }
51427 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51428 ecode2 = SWIG_AsVal_int(obj1, &val2);
51429 if (!SWIG_IsOK(ecode2)) {
51430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
51431 }
51432 arg2 = static_cast< int >(val2);
51433 {
51434 PyThreadState* __tstate = wxPyBeginAllowThreads();
51435 (arg1)->SetCols(arg2);
51436 wxPyEndAllowThreads(__tstate);
51437 if (PyErr_Occurred()) SWIG_fail;
51438 }
51439 resultobj = SWIG_Py_Void();
51440 return resultobj;
51441 fail:
51442 return NULL;
51443 }
51444
51445
51446 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51447 PyObject *resultobj = 0;
51448 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51449 int arg2 ;
51450 void *argp1 = 0 ;
51451 int res1 = 0 ;
51452 int val2 ;
51453 int ecode2 = 0 ;
51454 PyObject * obj0 = 0 ;
51455 PyObject * obj1 = 0 ;
51456 char * kwnames[] = {
51457 (char *) "self",(char *) "rows", NULL
51458 };
51459
51460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
51461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51462 if (!SWIG_IsOK(res1)) {
51463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51464 }
51465 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51466 ecode2 = SWIG_AsVal_int(obj1, &val2);
51467 if (!SWIG_IsOK(ecode2)) {
51468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
51469 }
51470 arg2 = static_cast< int >(val2);
51471 {
51472 PyThreadState* __tstate = wxPyBeginAllowThreads();
51473 (arg1)->SetRows(arg2);
51474 wxPyEndAllowThreads(__tstate);
51475 if (PyErr_Occurred()) SWIG_fail;
51476 }
51477 resultobj = SWIG_Py_Void();
51478 return resultobj;
51479 fail:
51480 return NULL;
51481 }
51482
51483
51484 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51485 PyObject *resultobj = 0;
51486 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51487 int arg2 ;
51488 void *argp1 = 0 ;
51489 int res1 = 0 ;
51490 int val2 ;
51491 int ecode2 = 0 ;
51492 PyObject * obj0 = 0 ;
51493 PyObject * obj1 = 0 ;
51494 char * kwnames[] = {
51495 (char *) "self",(char *) "gap", NULL
51496 };
51497
51498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
51499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51500 if (!SWIG_IsOK(res1)) {
51501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51502 }
51503 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51504 ecode2 = SWIG_AsVal_int(obj1, &val2);
51505 if (!SWIG_IsOK(ecode2)) {
51506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
51507 }
51508 arg2 = static_cast< int >(val2);
51509 {
51510 PyThreadState* __tstate = wxPyBeginAllowThreads();
51511 (arg1)->SetVGap(arg2);
51512 wxPyEndAllowThreads(__tstate);
51513 if (PyErr_Occurred()) SWIG_fail;
51514 }
51515 resultobj = SWIG_Py_Void();
51516 return resultobj;
51517 fail:
51518 return NULL;
51519 }
51520
51521
51522 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51523 PyObject *resultobj = 0;
51524 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51525 int arg2 ;
51526 void *argp1 = 0 ;
51527 int res1 = 0 ;
51528 int val2 ;
51529 int ecode2 = 0 ;
51530 PyObject * obj0 = 0 ;
51531 PyObject * obj1 = 0 ;
51532 char * kwnames[] = {
51533 (char *) "self",(char *) "gap", NULL
51534 };
51535
51536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
51537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51538 if (!SWIG_IsOK(res1)) {
51539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51540 }
51541 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51542 ecode2 = SWIG_AsVal_int(obj1, &val2);
51543 if (!SWIG_IsOK(ecode2)) {
51544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
51545 }
51546 arg2 = static_cast< int >(val2);
51547 {
51548 PyThreadState* __tstate = wxPyBeginAllowThreads();
51549 (arg1)->SetHGap(arg2);
51550 wxPyEndAllowThreads(__tstate);
51551 if (PyErr_Occurred()) SWIG_fail;
51552 }
51553 resultobj = SWIG_Py_Void();
51554 return resultobj;
51555 fail:
51556 return NULL;
51557 }
51558
51559
51560 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51561 PyObject *resultobj = 0;
51562 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51563 int result;
51564 void *argp1 = 0 ;
51565 int res1 = 0 ;
51566 PyObject *swig_obj[1] ;
51567
51568 if (!args) SWIG_fail;
51569 swig_obj[0] = args;
51570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51571 if (!SWIG_IsOK(res1)) {
51572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51573 }
51574 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51575 {
51576 PyThreadState* __tstate = wxPyBeginAllowThreads();
51577 result = (int)(arg1)->GetCols();
51578 wxPyEndAllowThreads(__tstate);
51579 if (PyErr_Occurred()) SWIG_fail;
51580 }
51581 resultobj = SWIG_From_int(static_cast< int >(result));
51582 return resultobj;
51583 fail:
51584 return NULL;
51585 }
51586
51587
51588 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51589 PyObject *resultobj = 0;
51590 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51591 int result;
51592 void *argp1 = 0 ;
51593 int res1 = 0 ;
51594 PyObject *swig_obj[1] ;
51595
51596 if (!args) SWIG_fail;
51597 swig_obj[0] = args;
51598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51599 if (!SWIG_IsOK(res1)) {
51600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51601 }
51602 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51603 {
51604 PyThreadState* __tstate = wxPyBeginAllowThreads();
51605 result = (int)(arg1)->GetRows();
51606 wxPyEndAllowThreads(__tstate);
51607 if (PyErr_Occurred()) SWIG_fail;
51608 }
51609 resultobj = SWIG_From_int(static_cast< int >(result));
51610 return resultobj;
51611 fail:
51612 return NULL;
51613 }
51614
51615
51616 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51617 PyObject *resultobj = 0;
51618 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51619 int result;
51620 void *argp1 = 0 ;
51621 int res1 = 0 ;
51622 PyObject *swig_obj[1] ;
51623
51624 if (!args) SWIG_fail;
51625 swig_obj[0] = args;
51626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51627 if (!SWIG_IsOK(res1)) {
51628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51629 }
51630 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51631 {
51632 PyThreadState* __tstate = wxPyBeginAllowThreads();
51633 result = (int)(arg1)->GetVGap();
51634 wxPyEndAllowThreads(__tstate);
51635 if (PyErr_Occurred()) SWIG_fail;
51636 }
51637 resultobj = SWIG_From_int(static_cast< int >(result));
51638 return resultobj;
51639 fail:
51640 return NULL;
51641 }
51642
51643
51644 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51645 PyObject *resultobj = 0;
51646 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51647 int result;
51648 void *argp1 = 0 ;
51649 int res1 = 0 ;
51650 PyObject *swig_obj[1] ;
51651
51652 if (!args) SWIG_fail;
51653 swig_obj[0] = args;
51654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51655 if (!SWIG_IsOK(res1)) {
51656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51657 }
51658 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51659 {
51660 PyThreadState* __tstate = wxPyBeginAllowThreads();
51661 result = (int)(arg1)->GetHGap();
51662 wxPyEndAllowThreads(__tstate);
51663 if (PyErr_Occurred()) SWIG_fail;
51664 }
51665 resultobj = SWIG_From_int(static_cast< int >(result));
51666 return resultobj;
51667 fail:
51668 return NULL;
51669 }
51670
51671
51672 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51673 PyObject *obj;
51674 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51675 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
51676 return SWIG_Py_Void();
51677 }
51678
51679 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51680 return SWIG_Python_InitShadowInstance(args);
51681 }
51682
51683 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51684 PyObject *resultobj = 0;
51685 int arg1 = (int) 1 ;
51686 int arg2 = (int) 0 ;
51687 int arg3 = (int) 0 ;
51688 int arg4 = (int) 0 ;
51689 wxFlexGridSizer *result = 0 ;
51690 int val1 ;
51691 int ecode1 = 0 ;
51692 int val2 ;
51693 int ecode2 = 0 ;
51694 int val3 ;
51695 int ecode3 = 0 ;
51696 int val4 ;
51697 int ecode4 = 0 ;
51698 PyObject * obj0 = 0 ;
51699 PyObject * obj1 = 0 ;
51700 PyObject * obj2 = 0 ;
51701 PyObject * obj3 = 0 ;
51702 char * kwnames[] = {
51703 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51704 };
51705
51706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51707 if (obj0) {
51708 ecode1 = SWIG_AsVal_int(obj0, &val1);
51709 if (!SWIG_IsOK(ecode1)) {
51710 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
51711 }
51712 arg1 = static_cast< int >(val1);
51713 }
51714 if (obj1) {
51715 ecode2 = SWIG_AsVal_int(obj1, &val2);
51716 if (!SWIG_IsOK(ecode2)) {
51717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
51718 }
51719 arg2 = static_cast< int >(val2);
51720 }
51721 if (obj2) {
51722 ecode3 = SWIG_AsVal_int(obj2, &val3);
51723 if (!SWIG_IsOK(ecode3)) {
51724 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
51725 }
51726 arg3 = static_cast< int >(val3);
51727 }
51728 if (obj3) {
51729 ecode4 = SWIG_AsVal_int(obj3, &val4);
51730 if (!SWIG_IsOK(ecode4)) {
51731 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
51732 }
51733 arg4 = static_cast< int >(val4);
51734 }
51735 {
51736 PyThreadState* __tstate = wxPyBeginAllowThreads();
51737 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
51738 wxPyEndAllowThreads(__tstate);
51739 if (PyErr_Occurred()) SWIG_fail;
51740 }
51741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
51742 return resultobj;
51743 fail:
51744 return NULL;
51745 }
51746
51747
51748 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51749 PyObject *resultobj = 0;
51750 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51751 size_t arg2 ;
51752 int arg3 = (int) 0 ;
51753 void *argp1 = 0 ;
51754 int res1 = 0 ;
51755 size_t val2 ;
51756 int ecode2 = 0 ;
51757 int val3 ;
51758 int ecode3 = 0 ;
51759 PyObject * obj0 = 0 ;
51760 PyObject * obj1 = 0 ;
51761 PyObject * obj2 = 0 ;
51762 char * kwnames[] = {
51763 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51764 };
51765
51766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51768 if (!SWIG_IsOK(res1)) {
51769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51770 }
51771 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51772 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51773 if (!SWIG_IsOK(ecode2)) {
51774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51775 }
51776 arg2 = static_cast< size_t >(val2);
51777 if (obj2) {
51778 ecode3 = SWIG_AsVal_int(obj2, &val3);
51779 if (!SWIG_IsOK(ecode3)) {
51780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
51781 }
51782 arg3 = static_cast< int >(val3);
51783 }
51784 {
51785 PyThreadState* __tstate = wxPyBeginAllowThreads();
51786 (arg1)->AddGrowableRow(arg2,arg3);
51787 wxPyEndAllowThreads(__tstate);
51788 if (PyErr_Occurred()) SWIG_fail;
51789 }
51790 resultobj = SWIG_Py_Void();
51791 return resultobj;
51792 fail:
51793 return NULL;
51794 }
51795
51796
51797 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51798 PyObject *resultobj = 0;
51799 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51800 size_t arg2 ;
51801 void *argp1 = 0 ;
51802 int res1 = 0 ;
51803 size_t val2 ;
51804 int ecode2 = 0 ;
51805 PyObject * obj0 = 0 ;
51806 PyObject * obj1 = 0 ;
51807 char * kwnames[] = {
51808 (char *) "self",(char *) "idx", NULL
51809 };
51810
51811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
51812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51813 if (!SWIG_IsOK(res1)) {
51814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51815 }
51816 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51817 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51818 if (!SWIG_IsOK(ecode2)) {
51819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51820 }
51821 arg2 = static_cast< size_t >(val2);
51822 {
51823 PyThreadState* __tstate = wxPyBeginAllowThreads();
51824 (arg1)->RemoveGrowableRow(arg2);
51825 wxPyEndAllowThreads(__tstate);
51826 if (PyErr_Occurred()) SWIG_fail;
51827 }
51828 resultobj = SWIG_Py_Void();
51829 return resultobj;
51830 fail:
51831 return NULL;
51832 }
51833
51834
51835 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51836 PyObject *resultobj = 0;
51837 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51838 size_t arg2 ;
51839 int arg3 = (int) 0 ;
51840 void *argp1 = 0 ;
51841 int res1 = 0 ;
51842 size_t val2 ;
51843 int ecode2 = 0 ;
51844 int val3 ;
51845 int ecode3 = 0 ;
51846 PyObject * obj0 = 0 ;
51847 PyObject * obj1 = 0 ;
51848 PyObject * obj2 = 0 ;
51849 char * kwnames[] = {
51850 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51851 };
51852
51853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51855 if (!SWIG_IsOK(res1)) {
51856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51857 }
51858 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51859 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51860 if (!SWIG_IsOK(ecode2)) {
51861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51862 }
51863 arg2 = static_cast< size_t >(val2);
51864 if (obj2) {
51865 ecode3 = SWIG_AsVal_int(obj2, &val3);
51866 if (!SWIG_IsOK(ecode3)) {
51867 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
51868 }
51869 arg3 = static_cast< int >(val3);
51870 }
51871 {
51872 PyThreadState* __tstate = wxPyBeginAllowThreads();
51873 (arg1)->AddGrowableCol(arg2,arg3);
51874 wxPyEndAllowThreads(__tstate);
51875 if (PyErr_Occurred()) SWIG_fail;
51876 }
51877 resultobj = SWIG_Py_Void();
51878 return resultobj;
51879 fail:
51880 return NULL;
51881 }
51882
51883
51884 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51885 PyObject *resultobj = 0;
51886 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51887 size_t arg2 ;
51888 void *argp1 = 0 ;
51889 int res1 = 0 ;
51890 size_t val2 ;
51891 int ecode2 = 0 ;
51892 PyObject * obj0 = 0 ;
51893 PyObject * obj1 = 0 ;
51894 char * kwnames[] = {
51895 (char *) "self",(char *) "idx", NULL
51896 };
51897
51898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
51899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51900 if (!SWIG_IsOK(res1)) {
51901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51902 }
51903 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51904 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51905 if (!SWIG_IsOK(ecode2)) {
51906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51907 }
51908 arg2 = static_cast< size_t >(val2);
51909 {
51910 PyThreadState* __tstate = wxPyBeginAllowThreads();
51911 (arg1)->RemoveGrowableCol(arg2);
51912 wxPyEndAllowThreads(__tstate);
51913 if (PyErr_Occurred()) SWIG_fail;
51914 }
51915 resultobj = SWIG_Py_Void();
51916 return resultobj;
51917 fail:
51918 return NULL;
51919 }
51920
51921
51922 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51923 PyObject *resultobj = 0;
51924 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51925 int arg2 ;
51926 void *argp1 = 0 ;
51927 int res1 = 0 ;
51928 int val2 ;
51929 int ecode2 = 0 ;
51930 PyObject * obj0 = 0 ;
51931 PyObject * obj1 = 0 ;
51932 char * kwnames[] = {
51933 (char *) "self",(char *) "direction", NULL
51934 };
51935
51936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
51937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51938 if (!SWIG_IsOK(res1)) {
51939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51940 }
51941 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51942 ecode2 = SWIG_AsVal_int(obj1, &val2);
51943 if (!SWIG_IsOK(ecode2)) {
51944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
51945 }
51946 arg2 = static_cast< int >(val2);
51947 {
51948 PyThreadState* __tstate = wxPyBeginAllowThreads();
51949 (arg1)->SetFlexibleDirection(arg2);
51950 wxPyEndAllowThreads(__tstate);
51951 if (PyErr_Occurred()) SWIG_fail;
51952 }
51953 resultobj = SWIG_Py_Void();
51954 return resultobj;
51955 fail:
51956 return NULL;
51957 }
51958
51959
51960 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51961 PyObject *resultobj = 0;
51962 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51963 int result;
51964 void *argp1 = 0 ;
51965 int res1 = 0 ;
51966 PyObject *swig_obj[1] ;
51967
51968 if (!args) SWIG_fail;
51969 swig_obj[0] = args;
51970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51971 if (!SWIG_IsOK(res1)) {
51972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51973 }
51974 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51975 {
51976 PyThreadState* __tstate = wxPyBeginAllowThreads();
51977 result = (int)(arg1)->GetFlexibleDirection();
51978 wxPyEndAllowThreads(__tstate);
51979 if (PyErr_Occurred()) SWIG_fail;
51980 }
51981 resultobj = SWIG_From_int(static_cast< int >(result));
51982 return resultobj;
51983 fail:
51984 return NULL;
51985 }
51986
51987
51988 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51989 PyObject *resultobj = 0;
51990 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51991 wxFlexSizerGrowMode arg2 ;
51992 void *argp1 = 0 ;
51993 int res1 = 0 ;
51994 int val2 ;
51995 int ecode2 = 0 ;
51996 PyObject * obj0 = 0 ;
51997 PyObject * obj1 = 0 ;
51998 char * kwnames[] = {
51999 (char *) "self",(char *) "mode", NULL
52000 };
52001
52002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
52003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52004 if (!SWIG_IsOK(res1)) {
52005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52006 }
52007 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52008 ecode2 = SWIG_AsVal_int(obj1, &val2);
52009 if (!SWIG_IsOK(ecode2)) {
52010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
52011 }
52012 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
52013 {
52014 PyThreadState* __tstate = wxPyBeginAllowThreads();
52015 (arg1)->SetNonFlexibleGrowMode(arg2);
52016 wxPyEndAllowThreads(__tstate);
52017 if (PyErr_Occurred()) SWIG_fail;
52018 }
52019 resultobj = SWIG_Py_Void();
52020 return resultobj;
52021 fail:
52022 return NULL;
52023 }
52024
52025
52026 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52027 PyObject *resultobj = 0;
52028 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52029 wxFlexSizerGrowMode result;
52030 void *argp1 = 0 ;
52031 int res1 = 0 ;
52032 PyObject *swig_obj[1] ;
52033
52034 if (!args) SWIG_fail;
52035 swig_obj[0] = args;
52036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52037 if (!SWIG_IsOK(res1)) {
52038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52039 }
52040 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52041 {
52042 PyThreadState* __tstate = wxPyBeginAllowThreads();
52043 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
52044 wxPyEndAllowThreads(__tstate);
52045 if (PyErr_Occurred()) SWIG_fail;
52046 }
52047 resultobj = SWIG_From_int(static_cast< int >(result));
52048 return resultobj;
52049 fail:
52050 return NULL;
52051 }
52052
52053
52054 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52055 PyObject *resultobj = 0;
52056 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52057 wxArrayInt *result = 0 ;
52058 void *argp1 = 0 ;
52059 int res1 = 0 ;
52060 PyObject *swig_obj[1] ;
52061
52062 if (!args) SWIG_fail;
52063 swig_obj[0] = args;
52064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52065 if (!SWIG_IsOK(res1)) {
52066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52067 }
52068 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52069 {
52070 PyThreadState* __tstate = wxPyBeginAllowThreads();
52071 {
52072 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
52073 result = (wxArrayInt *) &_result_ref;
52074 }
52075 wxPyEndAllowThreads(__tstate);
52076 if (PyErr_Occurred()) SWIG_fail;
52077 }
52078 {
52079 resultobj = wxArrayInt2PyList_helper(*result);
52080 }
52081 return resultobj;
52082 fail:
52083 return NULL;
52084 }
52085
52086
52087 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52088 PyObject *resultobj = 0;
52089 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52090 wxArrayInt *result = 0 ;
52091 void *argp1 = 0 ;
52092 int res1 = 0 ;
52093 PyObject *swig_obj[1] ;
52094
52095 if (!args) SWIG_fail;
52096 swig_obj[0] = args;
52097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52098 if (!SWIG_IsOK(res1)) {
52099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52100 }
52101 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52102 {
52103 PyThreadState* __tstate = wxPyBeginAllowThreads();
52104 {
52105 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
52106 result = (wxArrayInt *) &_result_ref;
52107 }
52108 wxPyEndAllowThreads(__tstate);
52109 if (PyErr_Occurred()) SWIG_fail;
52110 }
52111 {
52112 resultobj = wxArrayInt2PyList_helper(*result);
52113 }
52114 return resultobj;
52115 fail:
52116 return NULL;
52117 }
52118
52119
52120 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52121 PyObject *obj;
52122 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52123 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
52124 return SWIG_Py_Void();
52125 }
52126
52127 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52128 return SWIG_Python_InitShadowInstance(args);
52129 }
52130
52131 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52132 PyObject *resultobj = 0;
52133 wxStdDialogButtonSizer *result = 0 ;
52134
52135 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
52136 {
52137 PyThreadState* __tstate = wxPyBeginAllowThreads();
52138 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
52139 wxPyEndAllowThreads(__tstate);
52140 if (PyErr_Occurred()) SWIG_fail;
52141 }
52142 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
52143 return resultobj;
52144 fail:
52145 return NULL;
52146 }
52147
52148
52149 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52150 PyObject *resultobj = 0;
52151 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52152 wxButton *arg2 = (wxButton *) 0 ;
52153 void *argp1 = 0 ;
52154 int res1 = 0 ;
52155 void *argp2 = 0 ;
52156 int res2 = 0 ;
52157 PyObject * obj0 = 0 ;
52158 PyObject * obj1 = 0 ;
52159 char * kwnames[] = {
52160 (char *) "self",(char *) "button", NULL
52161 };
52162
52163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
52164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52165 if (!SWIG_IsOK(res1)) {
52166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52167 }
52168 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52169 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52170 if (!SWIG_IsOK(res2)) {
52171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
52172 }
52173 arg2 = reinterpret_cast< wxButton * >(argp2);
52174 {
52175 PyThreadState* __tstate = wxPyBeginAllowThreads();
52176 (arg1)->AddButton(arg2);
52177 wxPyEndAllowThreads(__tstate);
52178 if (PyErr_Occurred()) SWIG_fail;
52179 }
52180 resultobj = SWIG_Py_Void();
52181 return resultobj;
52182 fail:
52183 return NULL;
52184 }
52185
52186
52187 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52188 PyObject *resultobj = 0;
52189 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52190 void *argp1 = 0 ;
52191 int res1 = 0 ;
52192 PyObject *swig_obj[1] ;
52193
52194 if (!args) SWIG_fail;
52195 swig_obj[0] = args;
52196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52197 if (!SWIG_IsOK(res1)) {
52198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52199 }
52200 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52201 {
52202 PyThreadState* __tstate = wxPyBeginAllowThreads();
52203 (arg1)->Realize();
52204 wxPyEndAllowThreads(__tstate);
52205 if (PyErr_Occurred()) SWIG_fail;
52206 }
52207 resultobj = SWIG_Py_Void();
52208 return resultobj;
52209 fail:
52210 return NULL;
52211 }
52212
52213
52214 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52215 PyObject *resultobj = 0;
52216 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52217 wxButton *arg2 = (wxButton *) 0 ;
52218 void *argp1 = 0 ;
52219 int res1 = 0 ;
52220 void *argp2 = 0 ;
52221 int res2 = 0 ;
52222 PyObject * obj0 = 0 ;
52223 PyObject * obj1 = 0 ;
52224 char * kwnames[] = {
52225 (char *) "self",(char *) "button", NULL
52226 };
52227
52228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52230 if (!SWIG_IsOK(res1)) {
52231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52232 }
52233 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52234 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52235 if (!SWIG_IsOK(res2)) {
52236 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52237 }
52238 arg2 = reinterpret_cast< wxButton * >(argp2);
52239 {
52240 PyThreadState* __tstate = wxPyBeginAllowThreads();
52241 (arg1)->SetAffirmativeButton(arg2);
52242 wxPyEndAllowThreads(__tstate);
52243 if (PyErr_Occurred()) SWIG_fail;
52244 }
52245 resultobj = SWIG_Py_Void();
52246 return resultobj;
52247 fail:
52248 return NULL;
52249 }
52250
52251
52252 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52253 PyObject *resultobj = 0;
52254 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52255 wxButton *arg2 = (wxButton *) 0 ;
52256 void *argp1 = 0 ;
52257 int res1 = 0 ;
52258 void *argp2 = 0 ;
52259 int res2 = 0 ;
52260 PyObject * obj0 = 0 ;
52261 PyObject * obj1 = 0 ;
52262 char * kwnames[] = {
52263 (char *) "self",(char *) "button", NULL
52264 };
52265
52266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52268 if (!SWIG_IsOK(res1)) {
52269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52270 }
52271 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52272 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52273 if (!SWIG_IsOK(res2)) {
52274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52275 }
52276 arg2 = reinterpret_cast< wxButton * >(argp2);
52277 {
52278 PyThreadState* __tstate = wxPyBeginAllowThreads();
52279 (arg1)->SetNegativeButton(arg2);
52280 wxPyEndAllowThreads(__tstate);
52281 if (PyErr_Occurred()) SWIG_fail;
52282 }
52283 resultobj = SWIG_Py_Void();
52284 return resultobj;
52285 fail:
52286 return NULL;
52287 }
52288
52289
52290 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52291 PyObject *resultobj = 0;
52292 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52293 wxButton *arg2 = (wxButton *) 0 ;
52294 void *argp1 = 0 ;
52295 int res1 = 0 ;
52296 void *argp2 = 0 ;
52297 int res2 = 0 ;
52298 PyObject * obj0 = 0 ;
52299 PyObject * obj1 = 0 ;
52300 char * kwnames[] = {
52301 (char *) "self",(char *) "button", NULL
52302 };
52303
52304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
52305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52306 if (!SWIG_IsOK(res1)) {
52307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52308 }
52309 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52310 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52311 if (!SWIG_IsOK(res2)) {
52312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
52313 }
52314 arg2 = reinterpret_cast< wxButton * >(argp2);
52315 {
52316 PyThreadState* __tstate = wxPyBeginAllowThreads();
52317 (arg1)->SetCancelButton(arg2);
52318 wxPyEndAllowThreads(__tstate);
52319 if (PyErr_Occurred()) SWIG_fail;
52320 }
52321 resultobj = SWIG_Py_Void();
52322 return resultobj;
52323 fail:
52324 return NULL;
52325 }
52326
52327
52328 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52329 PyObject *resultobj = 0;
52330 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52331 wxButton *result = 0 ;
52332 void *argp1 = 0 ;
52333 int res1 = 0 ;
52334 PyObject *swig_obj[1] ;
52335
52336 if (!args) SWIG_fail;
52337 swig_obj[0] = args;
52338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52339 if (!SWIG_IsOK(res1)) {
52340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52341 }
52342 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52343 {
52344 PyThreadState* __tstate = wxPyBeginAllowThreads();
52345 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
52346 wxPyEndAllowThreads(__tstate);
52347 if (PyErr_Occurred()) SWIG_fail;
52348 }
52349 {
52350 resultobj = wxPyMake_wxObject(result, (bool)0);
52351 }
52352 return resultobj;
52353 fail:
52354 return NULL;
52355 }
52356
52357
52358 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52359 PyObject *resultobj = 0;
52360 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52361 wxButton *result = 0 ;
52362 void *argp1 = 0 ;
52363 int res1 = 0 ;
52364 PyObject *swig_obj[1] ;
52365
52366 if (!args) SWIG_fail;
52367 swig_obj[0] = args;
52368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52369 if (!SWIG_IsOK(res1)) {
52370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52371 }
52372 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52373 {
52374 PyThreadState* __tstate = wxPyBeginAllowThreads();
52375 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
52376 wxPyEndAllowThreads(__tstate);
52377 if (PyErr_Occurred()) SWIG_fail;
52378 }
52379 {
52380 resultobj = wxPyMake_wxObject(result, (bool)0);
52381 }
52382 return resultobj;
52383 fail:
52384 return NULL;
52385 }
52386
52387
52388 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52389 PyObject *resultobj = 0;
52390 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52391 wxButton *result = 0 ;
52392 void *argp1 = 0 ;
52393 int res1 = 0 ;
52394 PyObject *swig_obj[1] ;
52395
52396 if (!args) SWIG_fail;
52397 swig_obj[0] = args;
52398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52399 if (!SWIG_IsOK(res1)) {
52400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52401 }
52402 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52403 {
52404 PyThreadState* __tstate = wxPyBeginAllowThreads();
52405 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
52406 wxPyEndAllowThreads(__tstate);
52407 if (PyErr_Occurred()) SWIG_fail;
52408 }
52409 {
52410 resultobj = wxPyMake_wxObject(result, (bool)0);
52411 }
52412 return resultobj;
52413 fail:
52414 return NULL;
52415 }
52416
52417
52418 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52419 PyObject *resultobj = 0;
52420 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52421 wxButton *result = 0 ;
52422 void *argp1 = 0 ;
52423 int res1 = 0 ;
52424 PyObject *swig_obj[1] ;
52425
52426 if (!args) SWIG_fail;
52427 swig_obj[0] = args;
52428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52429 if (!SWIG_IsOK(res1)) {
52430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52431 }
52432 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52433 {
52434 PyThreadState* __tstate = wxPyBeginAllowThreads();
52435 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
52436 wxPyEndAllowThreads(__tstate);
52437 if (PyErr_Occurred()) SWIG_fail;
52438 }
52439 {
52440 resultobj = wxPyMake_wxObject(result, (bool)0);
52441 }
52442 return resultobj;
52443 fail:
52444 return NULL;
52445 }
52446
52447
52448 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52449 PyObject *resultobj = 0;
52450 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52451 wxButton *result = 0 ;
52452 void *argp1 = 0 ;
52453 int res1 = 0 ;
52454 PyObject *swig_obj[1] ;
52455
52456 if (!args) SWIG_fail;
52457 swig_obj[0] = args;
52458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52459 if (!SWIG_IsOK(res1)) {
52460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52461 }
52462 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52463 {
52464 PyThreadState* __tstate = wxPyBeginAllowThreads();
52465 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
52466 wxPyEndAllowThreads(__tstate);
52467 if (PyErr_Occurred()) SWIG_fail;
52468 }
52469 {
52470 resultobj = wxPyMake_wxObject(result, (bool)0);
52471 }
52472 return resultobj;
52473 fail:
52474 return NULL;
52475 }
52476
52477
52478 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52479 PyObject *obj;
52480 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52481 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
52482 return SWIG_Py_Void();
52483 }
52484
52485 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52486 return SWIG_Python_InitShadowInstance(args);
52487 }
52488
52489 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52490 PyObject *resultobj = 0;
52491 int arg1 = (int) 0 ;
52492 int arg2 = (int) 0 ;
52493 wxGBPosition *result = 0 ;
52494 int val1 ;
52495 int ecode1 = 0 ;
52496 int val2 ;
52497 int ecode2 = 0 ;
52498 PyObject * obj0 = 0 ;
52499 PyObject * obj1 = 0 ;
52500 char * kwnames[] = {
52501 (char *) "row",(char *) "col", NULL
52502 };
52503
52504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52505 if (obj0) {
52506 ecode1 = SWIG_AsVal_int(obj0, &val1);
52507 if (!SWIG_IsOK(ecode1)) {
52508 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
52509 }
52510 arg1 = static_cast< int >(val1);
52511 }
52512 if (obj1) {
52513 ecode2 = SWIG_AsVal_int(obj1, &val2);
52514 if (!SWIG_IsOK(ecode2)) {
52515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
52516 }
52517 arg2 = static_cast< int >(val2);
52518 }
52519 {
52520 PyThreadState* __tstate = wxPyBeginAllowThreads();
52521 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
52522 wxPyEndAllowThreads(__tstate);
52523 if (PyErr_Occurred()) SWIG_fail;
52524 }
52525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
52526 return resultobj;
52527 fail:
52528 return NULL;
52529 }
52530
52531
52532 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52533 PyObject *resultobj = 0;
52534 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52535 void *argp1 = 0 ;
52536 int res1 = 0 ;
52537 PyObject *swig_obj[1] ;
52538
52539 if (!args) SWIG_fail;
52540 swig_obj[0] = args;
52541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
52542 if (!SWIG_IsOK(res1)) {
52543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52544 }
52545 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52546 {
52547 PyThreadState* __tstate = wxPyBeginAllowThreads();
52548 delete arg1;
52549
52550 wxPyEndAllowThreads(__tstate);
52551 if (PyErr_Occurred()) SWIG_fail;
52552 }
52553 resultobj = SWIG_Py_Void();
52554 return resultobj;
52555 fail:
52556 return NULL;
52557 }
52558
52559
52560 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52561 PyObject *resultobj = 0;
52562 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52563 int result;
52564 void *argp1 = 0 ;
52565 int res1 = 0 ;
52566 PyObject *swig_obj[1] ;
52567
52568 if (!args) SWIG_fail;
52569 swig_obj[0] = args;
52570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52571 if (!SWIG_IsOK(res1)) {
52572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52573 }
52574 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52575 {
52576 PyThreadState* __tstate = wxPyBeginAllowThreads();
52577 result = (int)((wxGBPosition const *)arg1)->GetRow();
52578 wxPyEndAllowThreads(__tstate);
52579 if (PyErr_Occurred()) SWIG_fail;
52580 }
52581 resultobj = SWIG_From_int(static_cast< int >(result));
52582 return resultobj;
52583 fail:
52584 return NULL;
52585 }
52586
52587
52588 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52589 PyObject *resultobj = 0;
52590 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52591 int result;
52592 void *argp1 = 0 ;
52593 int res1 = 0 ;
52594 PyObject *swig_obj[1] ;
52595
52596 if (!args) SWIG_fail;
52597 swig_obj[0] = args;
52598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52599 if (!SWIG_IsOK(res1)) {
52600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52601 }
52602 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52603 {
52604 PyThreadState* __tstate = wxPyBeginAllowThreads();
52605 result = (int)((wxGBPosition const *)arg1)->GetCol();
52606 wxPyEndAllowThreads(__tstate);
52607 if (PyErr_Occurred()) SWIG_fail;
52608 }
52609 resultobj = SWIG_From_int(static_cast< int >(result));
52610 return resultobj;
52611 fail:
52612 return NULL;
52613 }
52614
52615
52616 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52617 PyObject *resultobj = 0;
52618 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52619 int arg2 ;
52620 void *argp1 = 0 ;
52621 int res1 = 0 ;
52622 int val2 ;
52623 int ecode2 = 0 ;
52624 PyObject * obj0 = 0 ;
52625 PyObject * obj1 = 0 ;
52626 char * kwnames[] = {
52627 (char *) "self",(char *) "row", NULL
52628 };
52629
52630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
52631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52632 if (!SWIG_IsOK(res1)) {
52633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52634 }
52635 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52636 ecode2 = SWIG_AsVal_int(obj1, &val2);
52637 if (!SWIG_IsOK(ecode2)) {
52638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
52639 }
52640 arg2 = static_cast< int >(val2);
52641 {
52642 PyThreadState* __tstate = wxPyBeginAllowThreads();
52643 (arg1)->SetRow(arg2);
52644 wxPyEndAllowThreads(__tstate);
52645 if (PyErr_Occurred()) SWIG_fail;
52646 }
52647 resultobj = SWIG_Py_Void();
52648 return resultobj;
52649 fail:
52650 return NULL;
52651 }
52652
52653
52654 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52655 PyObject *resultobj = 0;
52656 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52657 int arg2 ;
52658 void *argp1 = 0 ;
52659 int res1 = 0 ;
52660 int val2 ;
52661 int ecode2 = 0 ;
52662 PyObject * obj0 = 0 ;
52663 PyObject * obj1 = 0 ;
52664 char * kwnames[] = {
52665 (char *) "self",(char *) "col", NULL
52666 };
52667
52668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
52669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52670 if (!SWIG_IsOK(res1)) {
52671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52672 }
52673 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52674 ecode2 = SWIG_AsVal_int(obj1, &val2);
52675 if (!SWIG_IsOK(ecode2)) {
52676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
52677 }
52678 arg2 = static_cast< int >(val2);
52679 {
52680 PyThreadState* __tstate = wxPyBeginAllowThreads();
52681 (arg1)->SetCol(arg2);
52682 wxPyEndAllowThreads(__tstate);
52683 if (PyErr_Occurred()) SWIG_fail;
52684 }
52685 resultobj = SWIG_Py_Void();
52686 return resultobj;
52687 fail:
52688 return NULL;
52689 }
52690
52691
52692 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52693 PyObject *resultobj = 0;
52694 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52695 PyObject *arg2 = (PyObject *) 0 ;
52696 bool result;
52697 void *argp1 = 0 ;
52698 int res1 = 0 ;
52699 PyObject * obj0 = 0 ;
52700 PyObject * obj1 = 0 ;
52701 char * kwnames[] = {
52702 (char *) "self",(char *) "other", NULL
52703 };
52704
52705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
52706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52707 if (!SWIG_IsOK(res1)) {
52708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52709 }
52710 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52711 arg2 = obj1;
52712 {
52713 result = (bool)wxGBPosition___eq__(arg1,arg2);
52714 if (PyErr_Occurred()) SWIG_fail;
52715 }
52716 {
52717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52718 }
52719 return resultobj;
52720 fail:
52721 return NULL;
52722 }
52723
52724
52725 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52726 PyObject *resultobj = 0;
52727 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52728 PyObject *arg2 = (PyObject *) 0 ;
52729 bool result;
52730 void *argp1 = 0 ;
52731 int res1 = 0 ;
52732 PyObject * obj0 = 0 ;
52733 PyObject * obj1 = 0 ;
52734 char * kwnames[] = {
52735 (char *) "self",(char *) "other", NULL
52736 };
52737
52738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
52739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52740 if (!SWIG_IsOK(res1)) {
52741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52742 }
52743 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52744 arg2 = obj1;
52745 {
52746 result = (bool)wxGBPosition___ne__(arg1,arg2);
52747 if (PyErr_Occurred()) SWIG_fail;
52748 }
52749 {
52750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52751 }
52752 return resultobj;
52753 fail:
52754 return NULL;
52755 }
52756
52757
52758 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52759 PyObject *resultobj = 0;
52760 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52761 int arg2 = (int) 0 ;
52762 int arg3 = (int) 0 ;
52763 void *argp1 = 0 ;
52764 int res1 = 0 ;
52765 int val2 ;
52766 int ecode2 = 0 ;
52767 int val3 ;
52768 int ecode3 = 0 ;
52769 PyObject * obj0 = 0 ;
52770 PyObject * obj1 = 0 ;
52771 PyObject * obj2 = 0 ;
52772 char * kwnames[] = {
52773 (char *) "self",(char *) "row",(char *) "col", NULL
52774 };
52775
52776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52778 if (!SWIG_IsOK(res1)) {
52779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52780 }
52781 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52782 if (obj1) {
52783 ecode2 = SWIG_AsVal_int(obj1, &val2);
52784 if (!SWIG_IsOK(ecode2)) {
52785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
52786 }
52787 arg2 = static_cast< int >(val2);
52788 }
52789 if (obj2) {
52790 ecode3 = SWIG_AsVal_int(obj2, &val3);
52791 if (!SWIG_IsOK(ecode3)) {
52792 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
52793 }
52794 arg3 = static_cast< int >(val3);
52795 }
52796 {
52797 PyThreadState* __tstate = wxPyBeginAllowThreads();
52798 wxGBPosition_Set(arg1,arg2,arg3);
52799 wxPyEndAllowThreads(__tstate);
52800 if (PyErr_Occurred()) SWIG_fail;
52801 }
52802 resultobj = SWIG_Py_Void();
52803 return resultobj;
52804 fail:
52805 return NULL;
52806 }
52807
52808
52809 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52810 PyObject *resultobj = 0;
52811 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52812 PyObject *result = 0 ;
52813 void *argp1 = 0 ;
52814 int res1 = 0 ;
52815 PyObject *swig_obj[1] ;
52816
52817 if (!args) SWIG_fail;
52818 swig_obj[0] = args;
52819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52820 if (!SWIG_IsOK(res1)) {
52821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52822 }
52823 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52824 {
52825 PyThreadState* __tstate = wxPyBeginAllowThreads();
52826 result = (PyObject *)wxGBPosition_Get(arg1);
52827 wxPyEndAllowThreads(__tstate);
52828 if (PyErr_Occurred()) SWIG_fail;
52829 }
52830 resultobj = result;
52831 return resultobj;
52832 fail:
52833 return NULL;
52834 }
52835
52836
52837 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52838 PyObject *obj;
52839 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52840 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
52841 return SWIG_Py_Void();
52842 }
52843
52844 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52845 return SWIG_Python_InitShadowInstance(args);
52846 }
52847
52848 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52849 PyObject *resultobj = 0;
52850 int arg1 = (int) 1 ;
52851 int arg2 = (int) 1 ;
52852 wxGBSpan *result = 0 ;
52853 int val1 ;
52854 int ecode1 = 0 ;
52855 int val2 ;
52856 int ecode2 = 0 ;
52857 PyObject * obj0 = 0 ;
52858 PyObject * obj1 = 0 ;
52859 char * kwnames[] = {
52860 (char *) "rowspan",(char *) "colspan", NULL
52861 };
52862
52863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
52864 if (obj0) {
52865 ecode1 = SWIG_AsVal_int(obj0, &val1);
52866 if (!SWIG_IsOK(ecode1)) {
52867 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
52868 }
52869 arg1 = static_cast< int >(val1);
52870 }
52871 if (obj1) {
52872 ecode2 = SWIG_AsVal_int(obj1, &val2);
52873 if (!SWIG_IsOK(ecode2)) {
52874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
52875 }
52876 arg2 = static_cast< int >(val2);
52877 }
52878 {
52879 PyThreadState* __tstate = wxPyBeginAllowThreads();
52880 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
52881 wxPyEndAllowThreads(__tstate);
52882 if (PyErr_Occurred()) SWIG_fail;
52883 }
52884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
52885 return resultobj;
52886 fail:
52887 return NULL;
52888 }
52889
52890
52891 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52892 PyObject *resultobj = 0;
52893 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52894 void *argp1 = 0 ;
52895 int res1 = 0 ;
52896 PyObject *swig_obj[1] ;
52897
52898 if (!args) SWIG_fail;
52899 swig_obj[0] = args;
52900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
52901 if (!SWIG_IsOK(res1)) {
52902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52903 }
52904 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52905 {
52906 PyThreadState* __tstate = wxPyBeginAllowThreads();
52907 delete arg1;
52908
52909 wxPyEndAllowThreads(__tstate);
52910 if (PyErr_Occurred()) SWIG_fail;
52911 }
52912 resultobj = SWIG_Py_Void();
52913 return resultobj;
52914 fail:
52915 return NULL;
52916 }
52917
52918
52919 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52920 PyObject *resultobj = 0;
52921 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52922 int result;
52923 void *argp1 = 0 ;
52924 int res1 = 0 ;
52925 PyObject *swig_obj[1] ;
52926
52927 if (!args) SWIG_fail;
52928 swig_obj[0] = args;
52929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52930 if (!SWIG_IsOK(res1)) {
52931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
52932 }
52933 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52934 {
52935 PyThreadState* __tstate = wxPyBeginAllowThreads();
52936 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
52937 wxPyEndAllowThreads(__tstate);
52938 if (PyErr_Occurred()) SWIG_fail;
52939 }
52940 resultobj = SWIG_From_int(static_cast< int >(result));
52941 return resultobj;
52942 fail:
52943 return NULL;
52944 }
52945
52946
52947 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52948 PyObject *resultobj = 0;
52949 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52950 int result;
52951 void *argp1 = 0 ;
52952 int res1 = 0 ;
52953 PyObject *swig_obj[1] ;
52954
52955 if (!args) SWIG_fail;
52956 swig_obj[0] = args;
52957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52958 if (!SWIG_IsOK(res1)) {
52959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
52960 }
52961 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52962 {
52963 PyThreadState* __tstate = wxPyBeginAllowThreads();
52964 result = (int)((wxGBSpan const *)arg1)->GetColspan();
52965 wxPyEndAllowThreads(__tstate);
52966 if (PyErr_Occurred()) SWIG_fail;
52967 }
52968 resultobj = SWIG_From_int(static_cast< int >(result));
52969 return resultobj;
52970 fail:
52971 return NULL;
52972 }
52973
52974
52975 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52976 PyObject *resultobj = 0;
52977 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52978 int arg2 ;
52979 void *argp1 = 0 ;
52980 int res1 = 0 ;
52981 int val2 ;
52982 int ecode2 = 0 ;
52983 PyObject * obj0 = 0 ;
52984 PyObject * obj1 = 0 ;
52985 char * kwnames[] = {
52986 (char *) "self",(char *) "rowspan", NULL
52987 };
52988
52989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
52990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52991 if (!SWIG_IsOK(res1)) {
52992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52993 }
52994 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52995 ecode2 = SWIG_AsVal_int(obj1, &val2);
52996 if (!SWIG_IsOK(ecode2)) {
52997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
52998 }
52999 arg2 = static_cast< int >(val2);
53000 {
53001 PyThreadState* __tstate = wxPyBeginAllowThreads();
53002 (arg1)->SetRowspan(arg2);
53003 wxPyEndAllowThreads(__tstate);
53004 if (PyErr_Occurred()) SWIG_fail;
53005 }
53006 resultobj = SWIG_Py_Void();
53007 return resultobj;
53008 fail:
53009 return NULL;
53010 }
53011
53012
53013 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53014 PyObject *resultobj = 0;
53015 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53016 int arg2 ;
53017 void *argp1 = 0 ;
53018 int res1 = 0 ;
53019 int val2 ;
53020 int ecode2 = 0 ;
53021 PyObject * obj0 = 0 ;
53022 PyObject * obj1 = 0 ;
53023 char * kwnames[] = {
53024 (char *) "self",(char *) "colspan", NULL
53025 };
53026
53027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
53028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53029 if (!SWIG_IsOK(res1)) {
53030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53031 }
53032 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53033 ecode2 = SWIG_AsVal_int(obj1, &val2);
53034 if (!SWIG_IsOK(ecode2)) {
53035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
53036 }
53037 arg2 = static_cast< int >(val2);
53038 {
53039 PyThreadState* __tstate = wxPyBeginAllowThreads();
53040 (arg1)->SetColspan(arg2);
53041 wxPyEndAllowThreads(__tstate);
53042 if (PyErr_Occurred()) SWIG_fail;
53043 }
53044 resultobj = SWIG_Py_Void();
53045 return resultobj;
53046 fail:
53047 return NULL;
53048 }
53049
53050
53051 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53052 PyObject *resultobj = 0;
53053 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53054 PyObject *arg2 = (PyObject *) 0 ;
53055 bool result;
53056 void *argp1 = 0 ;
53057 int res1 = 0 ;
53058 PyObject * obj0 = 0 ;
53059 PyObject * obj1 = 0 ;
53060 char * kwnames[] = {
53061 (char *) "self",(char *) "other", NULL
53062 };
53063
53064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
53065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53066 if (!SWIG_IsOK(res1)) {
53067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53068 }
53069 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53070 arg2 = obj1;
53071 {
53072 result = (bool)wxGBSpan___eq__(arg1,arg2);
53073 if (PyErr_Occurred()) SWIG_fail;
53074 }
53075 {
53076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53077 }
53078 return resultobj;
53079 fail:
53080 return NULL;
53081 }
53082
53083
53084 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53085 PyObject *resultobj = 0;
53086 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53087 PyObject *arg2 = (PyObject *) 0 ;
53088 bool result;
53089 void *argp1 = 0 ;
53090 int res1 = 0 ;
53091 PyObject * obj0 = 0 ;
53092 PyObject * obj1 = 0 ;
53093 char * kwnames[] = {
53094 (char *) "self",(char *) "other", NULL
53095 };
53096
53097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
53098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53099 if (!SWIG_IsOK(res1)) {
53100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53101 }
53102 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53103 arg2 = obj1;
53104 {
53105 result = (bool)wxGBSpan___ne__(arg1,arg2);
53106 if (PyErr_Occurred()) SWIG_fail;
53107 }
53108 {
53109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53110 }
53111 return resultobj;
53112 fail:
53113 return NULL;
53114 }
53115
53116
53117 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53118 PyObject *resultobj = 0;
53119 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53120 int arg2 = (int) 1 ;
53121 int arg3 = (int) 1 ;
53122 void *argp1 = 0 ;
53123 int res1 = 0 ;
53124 int val2 ;
53125 int ecode2 = 0 ;
53126 int val3 ;
53127 int ecode3 = 0 ;
53128 PyObject * obj0 = 0 ;
53129 PyObject * obj1 = 0 ;
53130 PyObject * obj2 = 0 ;
53131 char * kwnames[] = {
53132 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
53133 };
53134
53135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53137 if (!SWIG_IsOK(res1)) {
53138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53139 }
53140 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53141 if (obj1) {
53142 ecode2 = SWIG_AsVal_int(obj1, &val2);
53143 if (!SWIG_IsOK(ecode2)) {
53144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
53145 }
53146 arg2 = static_cast< int >(val2);
53147 }
53148 if (obj2) {
53149 ecode3 = SWIG_AsVal_int(obj2, &val3);
53150 if (!SWIG_IsOK(ecode3)) {
53151 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
53152 }
53153 arg3 = static_cast< int >(val3);
53154 }
53155 {
53156 PyThreadState* __tstate = wxPyBeginAllowThreads();
53157 wxGBSpan_Set(arg1,arg2,arg3);
53158 wxPyEndAllowThreads(__tstate);
53159 if (PyErr_Occurred()) SWIG_fail;
53160 }
53161 resultobj = SWIG_Py_Void();
53162 return resultobj;
53163 fail:
53164 return NULL;
53165 }
53166
53167
53168 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53169 PyObject *resultobj = 0;
53170 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53171 PyObject *result = 0 ;
53172 void *argp1 = 0 ;
53173 int res1 = 0 ;
53174 PyObject *swig_obj[1] ;
53175
53176 if (!args) SWIG_fail;
53177 swig_obj[0] = args;
53178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53179 if (!SWIG_IsOK(res1)) {
53180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53181 }
53182 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53183 {
53184 PyThreadState* __tstate = wxPyBeginAllowThreads();
53185 result = (PyObject *)wxGBSpan_Get(arg1);
53186 wxPyEndAllowThreads(__tstate);
53187 if (PyErr_Occurred()) SWIG_fail;
53188 }
53189 resultobj = result;
53190 return resultobj;
53191 fail:
53192 return NULL;
53193 }
53194
53195
53196 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53197 PyObject *obj;
53198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53199 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
53200 return SWIG_Py_Void();
53201 }
53202
53203 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53204 return SWIG_Python_InitShadowInstance(args);
53205 }
53206
53207 SWIGINTERN int DefaultSpan_set(PyObject *) {
53208 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
53209 return 1;
53210 }
53211
53212
53213 SWIGINTERN PyObject *DefaultSpan_get(void) {
53214 PyObject *pyobj = 0;
53215
53216 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
53217 return pyobj;
53218 }
53219
53220
53221 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53222 PyObject *resultobj = 0;
53223 wxGBSizerItem *result = 0 ;
53224
53225 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
53226 {
53227 PyThreadState* __tstate = wxPyBeginAllowThreads();
53228 result = (wxGBSizerItem *)new wxGBSizerItem();
53229 wxPyEndAllowThreads(__tstate);
53230 if (PyErr_Occurred()) SWIG_fail;
53231 }
53232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
53233 return resultobj;
53234 fail:
53235 return NULL;
53236 }
53237
53238
53239 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53240 PyObject *resultobj = 0;
53241 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53242 void *argp1 = 0 ;
53243 int res1 = 0 ;
53244 PyObject *swig_obj[1] ;
53245
53246 if (!args) SWIG_fail;
53247 swig_obj[0] = args;
53248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53249 if (!SWIG_IsOK(res1)) {
53250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53251 }
53252 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53253 {
53254 PyThreadState* __tstate = wxPyBeginAllowThreads();
53255 delete arg1;
53256
53257 wxPyEndAllowThreads(__tstate);
53258 if (PyErr_Occurred()) SWIG_fail;
53259 }
53260 resultobj = SWIG_Py_Void();
53261 return resultobj;
53262 fail:
53263 return NULL;
53264 }
53265
53266
53267 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53268 PyObject *resultobj = 0;
53269 wxWindow *arg1 = (wxWindow *) 0 ;
53270 wxGBPosition *arg2 = 0 ;
53271 wxGBSpan *arg3 = 0 ;
53272 int arg4 ;
53273 int arg5 ;
53274 PyObject *arg6 = (PyObject *) NULL ;
53275 wxGBSizerItem *result = 0 ;
53276 void *argp1 = 0 ;
53277 int res1 = 0 ;
53278 wxGBPosition temp2 ;
53279 wxGBSpan temp3 ;
53280 int val4 ;
53281 int ecode4 = 0 ;
53282 int val5 ;
53283 int ecode5 = 0 ;
53284 PyObject * obj0 = 0 ;
53285 PyObject * obj1 = 0 ;
53286 PyObject * obj2 = 0 ;
53287 PyObject * obj3 = 0 ;
53288 PyObject * obj4 = 0 ;
53289 PyObject * obj5 = 0 ;
53290 char * kwnames[] = {
53291 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53292 };
53293
53294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
53296 if (!SWIG_IsOK(res1)) {
53297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
53298 }
53299 arg1 = reinterpret_cast< wxWindow * >(argp1);
53300 {
53301 arg2 = &temp2;
53302 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53303 }
53304 {
53305 arg3 = &temp3;
53306 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53307 }
53308 ecode4 = SWIG_AsVal_int(obj3, &val4);
53309 if (!SWIG_IsOK(ecode4)) {
53310 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
53311 }
53312 arg4 = static_cast< int >(val4);
53313 ecode5 = SWIG_AsVal_int(obj4, &val5);
53314 if (!SWIG_IsOK(ecode5)) {
53315 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
53316 }
53317 arg5 = static_cast< int >(val5);
53318 if (obj5) {
53319 arg6 = obj5;
53320 }
53321 {
53322 PyThreadState* __tstate = wxPyBeginAllowThreads();
53323 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53324 wxPyEndAllowThreads(__tstate);
53325 if (PyErr_Occurred()) SWIG_fail;
53326 }
53327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53328 return resultobj;
53329 fail:
53330 return NULL;
53331 }
53332
53333
53334 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53335 PyObject *resultobj = 0;
53336 wxSizer *arg1 = (wxSizer *) 0 ;
53337 wxGBPosition *arg2 = 0 ;
53338 wxGBSpan *arg3 = 0 ;
53339 int arg4 ;
53340 int arg5 ;
53341 PyObject *arg6 = (PyObject *) NULL ;
53342 wxGBSizerItem *result = 0 ;
53343 int res1 = 0 ;
53344 wxGBPosition temp2 ;
53345 wxGBSpan temp3 ;
53346 int val4 ;
53347 int ecode4 = 0 ;
53348 int val5 ;
53349 int ecode5 = 0 ;
53350 PyObject * obj0 = 0 ;
53351 PyObject * obj1 = 0 ;
53352 PyObject * obj2 = 0 ;
53353 PyObject * obj3 = 0 ;
53354 PyObject * obj4 = 0 ;
53355 PyObject * obj5 = 0 ;
53356 char * kwnames[] = {
53357 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53358 };
53359
53360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53361 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
53362 if (!SWIG_IsOK(res1)) {
53363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
53364 }
53365 {
53366 arg2 = &temp2;
53367 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53368 }
53369 {
53370 arg3 = &temp3;
53371 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53372 }
53373 ecode4 = SWIG_AsVal_int(obj3, &val4);
53374 if (!SWIG_IsOK(ecode4)) {
53375 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
53376 }
53377 arg4 = static_cast< int >(val4);
53378 ecode5 = SWIG_AsVal_int(obj4, &val5);
53379 if (!SWIG_IsOK(ecode5)) {
53380 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
53381 }
53382 arg5 = static_cast< int >(val5);
53383 if (obj5) {
53384 arg6 = obj5;
53385 }
53386 {
53387 PyThreadState* __tstate = wxPyBeginAllowThreads();
53388 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53389 wxPyEndAllowThreads(__tstate);
53390 if (PyErr_Occurred()) SWIG_fail;
53391 }
53392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53393 return resultobj;
53394 fail:
53395 return NULL;
53396 }
53397
53398
53399 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53400 PyObject *resultobj = 0;
53401 int arg1 ;
53402 int arg2 ;
53403 wxGBPosition *arg3 = 0 ;
53404 wxGBSpan *arg4 = 0 ;
53405 int arg5 ;
53406 int arg6 ;
53407 PyObject *arg7 = (PyObject *) NULL ;
53408 wxGBSizerItem *result = 0 ;
53409 int val1 ;
53410 int ecode1 = 0 ;
53411 int val2 ;
53412 int ecode2 = 0 ;
53413 wxGBPosition temp3 ;
53414 wxGBSpan temp4 ;
53415 int val5 ;
53416 int ecode5 = 0 ;
53417 int val6 ;
53418 int ecode6 = 0 ;
53419 PyObject * obj0 = 0 ;
53420 PyObject * obj1 = 0 ;
53421 PyObject * obj2 = 0 ;
53422 PyObject * obj3 = 0 ;
53423 PyObject * obj4 = 0 ;
53424 PyObject * obj5 = 0 ;
53425 PyObject * obj6 = 0 ;
53426 char * kwnames[] = {
53427 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53428 };
53429
53430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53431 ecode1 = SWIG_AsVal_int(obj0, &val1);
53432 if (!SWIG_IsOK(ecode1)) {
53433 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
53434 }
53435 arg1 = static_cast< int >(val1);
53436 ecode2 = SWIG_AsVal_int(obj1, &val2);
53437 if (!SWIG_IsOK(ecode2)) {
53438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
53439 }
53440 arg2 = static_cast< int >(val2);
53441 {
53442 arg3 = &temp3;
53443 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53444 }
53445 {
53446 arg4 = &temp4;
53447 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53448 }
53449 ecode5 = SWIG_AsVal_int(obj4, &val5);
53450 if (!SWIG_IsOK(ecode5)) {
53451 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
53452 }
53453 arg5 = static_cast< int >(val5);
53454 ecode6 = SWIG_AsVal_int(obj5, &val6);
53455 if (!SWIG_IsOK(ecode6)) {
53456 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
53457 }
53458 arg6 = static_cast< int >(val6);
53459 if (obj6) {
53460 arg7 = obj6;
53461 }
53462 {
53463 PyThreadState* __tstate = wxPyBeginAllowThreads();
53464 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53465 wxPyEndAllowThreads(__tstate);
53466 if (PyErr_Occurred()) SWIG_fail;
53467 }
53468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53469 return resultobj;
53470 fail:
53471 return NULL;
53472 }
53473
53474
53475 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53476 PyObject *resultobj = 0;
53477 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53478 wxGBPosition result;
53479 void *argp1 = 0 ;
53480 int res1 = 0 ;
53481 PyObject *swig_obj[1] ;
53482
53483 if (!args) SWIG_fail;
53484 swig_obj[0] = args;
53485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53486 if (!SWIG_IsOK(res1)) {
53487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53488 }
53489 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53490 {
53491 PyThreadState* __tstate = wxPyBeginAllowThreads();
53492 result = ((wxGBSizerItem const *)arg1)->GetPos();
53493 wxPyEndAllowThreads(__tstate);
53494 if (PyErr_Occurred()) SWIG_fail;
53495 }
53496 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53497 return resultobj;
53498 fail:
53499 return NULL;
53500 }
53501
53502
53503 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53504 PyObject *resultobj = 0;
53505 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53506 wxGBSpan result;
53507 void *argp1 = 0 ;
53508 int res1 = 0 ;
53509 PyObject *swig_obj[1] ;
53510
53511 if (!args) SWIG_fail;
53512 swig_obj[0] = args;
53513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53514 if (!SWIG_IsOK(res1)) {
53515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53516 }
53517 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53518 {
53519 PyThreadState* __tstate = wxPyBeginAllowThreads();
53520 result = ((wxGBSizerItem const *)arg1)->GetSpan();
53521 wxPyEndAllowThreads(__tstate);
53522 if (PyErr_Occurred()) SWIG_fail;
53523 }
53524 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
53525 return resultobj;
53526 fail:
53527 return NULL;
53528 }
53529
53530
53531 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53532 PyObject *resultobj = 0;
53533 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53534 wxGBPosition *arg2 = 0 ;
53535 bool result;
53536 void *argp1 = 0 ;
53537 int res1 = 0 ;
53538 wxGBPosition temp2 ;
53539 PyObject * obj0 = 0 ;
53540 PyObject * obj1 = 0 ;
53541 char * kwnames[] = {
53542 (char *) "self",(char *) "pos", NULL
53543 };
53544
53545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
53546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53547 if (!SWIG_IsOK(res1)) {
53548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53549 }
53550 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53551 {
53552 arg2 = &temp2;
53553 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53554 }
53555 {
53556 PyThreadState* __tstate = wxPyBeginAllowThreads();
53557 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
53558 wxPyEndAllowThreads(__tstate);
53559 if (PyErr_Occurred()) SWIG_fail;
53560 }
53561 {
53562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53563 }
53564 return resultobj;
53565 fail:
53566 return NULL;
53567 }
53568
53569
53570 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53571 PyObject *resultobj = 0;
53572 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53573 wxGBSpan *arg2 = 0 ;
53574 bool result;
53575 void *argp1 = 0 ;
53576 int res1 = 0 ;
53577 wxGBSpan temp2 ;
53578 PyObject * obj0 = 0 ;
53579 PyObject * obj1 = 0 ;
53580 char * kwnames[] = {
53581 (char *) "self",(char *) "span", NULL
53582 };
53583
53584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53586 if (!SWIG_IsOK(res1)) {
53587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53588 }
53589 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53590 {
53591 arg2 = &temp2;
53592 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
53593 }
53594 {
53595 PyThreadState* __tstate = wxPyBeginAllowThreads();
53596 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
53597 wxPyEndAllowThreads(__tstate);
53598 if (PyErr_Occurred()) SWIG_fail;
53599 }
53600 {
53601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53602 }
53603 return resultobj;
53604 fail:
53605 return NULL;
53606 }
53607
53608
53609 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53610 PyObject *resultobj = 0;
53611 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53612 wxGBSizerItem *arg2 = 0 ;
53613 bool result;
53614 void *argp1 = 0 ;
53615 int res1 = 0 ;
53616 void *argp2 = 0 ;
53617 int res2 = 0 ;
53618 PyObject * obj0 = 0 ;
53619 PyObject * obj1 = 0 ;
53620 char * kwnames[] = {
53621 (char *) "self",(char *) "other", NULL
53622 };
53623
53624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
53625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53626 if (!SWIG_IsOK(res1)) {
53627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53628 }
53629 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53630 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
53631 if (!SWIG_IsOK(res2)) {
53632 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53633 }
53634 if (!argp2) {
53635 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53636 }
53637 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
53638 {
53639 PyThreadState* __tstate = wxPyBeginAllowThreads();
53640 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
53641 wxPyEndAllowThreads(__tstate);
53642 if (PyErr_Occurred()) SWIG_fail;
53643 }
53644 {
53645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53646 }
53647 return resultobj;
53648 fail:
53649 return NULL;
53650 }
53651
53652
53653 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53654 PyObject *resultobj = 0;
53655 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53656 wxGBPosition *arg2 = 0 ;
53657 wxGBSpan *arg3 = 0 ;
53658 bool result;
53659 void *argp1 = 0 ;
53660 int res1 = 0 ;
53661 wxGBPosition temp2 ;
53662 wxGBSpan temp3 ;
53663 PyObject * obj0 = 0 ;
53664 PyObject * obj1 = 0 ;
53665 PyObject * obj2 = 0 ;
53666 char * kwnames[] = {
53667 (char *) "self",(char *) "pos",(char *) "span", NULL
53668 };
53669
53670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53672 if (!SWIG_IsOK(res1)) {
53673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53674 }
53675 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53676 {
53677 arg2 = &temp2;
53678 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53679 }
53680 {
53681 arg3 = &temp3;
53682 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53683 }
53684 {
53685 PyThreadState* __tstate = wxPyBeginAllowThreads();
53686 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
53687 wxPyEndAllowThreads(__tstate);
53688 if (PyErr_Occurred()) SWIG_fail;
53689 }
53690 {
53691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53692 }
53693 return resultobj;
53694 fail:
53695 return NULL;
53696 }
53697
53698
53699 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53700 PyObject *resultobj = 0;
53701 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53702 wxGBPosition result;
53703 void *argp1 = 0 ;
53704 int res1 = 0 ;
53705 PyObject *swig_obj[1] ;
53706
53707 if (!args) SWIG_fail;
53708 swig_obj[0] = args;
53709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53710 if (!SWIG_IsOK(res1)) {
53711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53712 }
53713 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53714 {
53715 PyThreadState* __tstate = wxPyBeginAllowThreads();
53716 result = wxGBSizerItem_GetEndPos(arg1);
53717 wxPyEndAllowThreads(__tstate);
53718 if (PyErr_Occurred()) SWIG_fail;
53719 }
53720 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53721 return resultobj;
53722 fail:
53723 return NULL;
53724 }
53725
53726
53727 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53728 PyObject *resultobj = 0;
53729 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53730 wxGridBagSizer *result = 0 ;
53731 void *argp1 = 0 ;
53732 int res1 = 0 ;
53733 PyObject *swig_obj[1] ;
53734
53735 if (!args) SWIG_fail;
53736 swig_obj[0] = args;
53737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53738 if (!SWIG_IsOK(res1)) {
53739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53740 }
53741 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53742 {
53743 PyThreadState* __tstate = wxPyBeginAllowThreads();
53744 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
53745 wxPyEndAllowThreads(__tstate);
53746 if (PyErr_Occurred()) SWIG_fail;
53747 }
53748 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53749 return resultobj;
53750 fail:
53751 return NULL;
53752 }
53753
53754
53755 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53756 PyObject *resultobj = 0;
53757 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53758 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
53759 void *argp1 = 0 ;
53760 int res1 = 0 ;
53761 void *argp2 = 0 ;
53762 int res2 = 0 ;
53763 PyObject * obj0 = 0 ;
53764 PyObject * obj1 = 0 ;
53765 char * kwnames[] = {
53766 (char *) "self",(char *) "sizer", NULL
53767 };
53768
53769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53771 if (!SWIG_IsOK(res1)) {
53772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53773 }
53774 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53775 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53776 if (!SWIG_IsOK(res2)) {
53777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
53778 }
53779 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
53780 {
53781 PyThreadState* __tstate = wxPyBeginAllowThreads();
53782 (arg1)->SetGBSizer(arg2);
53783 wxPyEndAllowThreads(__tstate);
53784 if (PyErr_Occurred()) SWIG_fail;
53785 }
53786 resultobj = SWIG_Py_Void();
53787 return resultobj;
53788 fail:
53789 return NULL;
53790 }
53791
53792
53793 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53794 PyObject *obj;
53795 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53796 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
53797 return SWIG_Py_Void();
53798 }
53799
53800 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53801 return SWIG_Python_InitShadowInstance(args);
53802 }
53803
53804 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53805 PyObject *resultobj = 0;
53806 int arg1 = (int) 0 ;
53807 int arg2 = (int) 0 ;
53808 wxGridBagSizer *result = 0 ;
53809 int val1 ;
53810 int ecode1 = 0 ;
53811 int val2 ;
53812 int ecode2 = 0 ;
53813 PyObject * obj0 = 0 ;
53814 PyObject * obj1 = 0 ;
53815 char * kwnames[] = {
53816 (char *) "vgap",(char *) "hgap", NULL
53817 };
53818
53819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53820 if (obj0) {
53821 ecode1 = SWIG_AsVal_int(obj0, &val1);
53822 if (!SWIG_IsOK(ecode1)) {
53823 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
53824 }
53825 arg1 = static_cast< int >(val1);
53826 }
53827 if (obj1) {
53828 ecode2 = SWIG_AsVal_int(obj1, &val2);
53829 if (!SWIG_IsOK(ecode2)) {
53830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
53831 }
53832 arg2 = static_cast< int >(val2);
53833 }
53834 {
53835 PyThreadState* __tstate = wxPyBeginAllowThreads();
53836 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
53837 wxPyEndAllowThreads(__tstate);
53838 if (PyErr_Occurred()) SWIG_fail;
53839 }
53840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
53841 return resultobj;
53842 fail:
53843 return NULL;
53844 }
53845
53846
53847 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53848 PyObject *resultobj = 0;
53849 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53850 PyObject *arg2 = (PyObject *) 0 ;
53851 wxGBPosition *arg3 = 0 ;
53852 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
53853 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
53854 int arg5 = (int) 0 ;
53855 int arg6 = (int) 0 ;
53856 PyObject *arg7 = (PyObject *) NULL ;
53857 wxGBSizerItem *result = 0 ;
53858 void *argp1 = 0 ;
53859 int res1 = 0 ;
53860 wxGBPosition temp3 ;
53861 wxGBSpan temp4 ;
53862 int val5 ;
53863 int ecode5 = 0 ;
53864 int val6 ;
53865 int ecode6 = 0 ;
53866 PyObject * obj0 = 0 ;
53867 PyObject * obj1 = 0 ;
53868 PyObject * obj2 = 0 ;
53869 PyObject * obj3 = 0 ;
53870 PyObject * obj4 = 0 ;
53871 PyObject * obj5 = 0 ;
53872 PyObject * obj6 = 0 ;
53873 char * kwnames[] = {
53874 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53875 };
53876
53877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53879 if (!SWIG_IsOK(res1)) {
53880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53881 }
53882 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53883 arg2 = obj1;
53884 {
53885 arg3 = &temp3;
53886 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53887 }
53888 if (obj3) {
53889 {
53890 arg4 = &temp4;
53891 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53892 }
53893 }
53894 if (obj4) {
53895 ecode5 = SWIG_AsVal_int(obj4, &val5);
53896 if (!SWIG_IsOK(ecode5)) {
53897 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
53898 }
53899 arg5 = static_cast< int >(val5);
53900 }
53901 if (obj5) {
53902 ecode6 = SWIG_AsVal_int(obj5, &val6);
53903 if (!SWIG_IsOK(ecode6)) {
53904 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
53905 }
53906 arg6 = static_cast< int >(val6);
53907 }
53908 if (obj6) {
53909 arg7 = obj6;
53910 }
53911 {
53912 PyThreadState* __tstate = wxPyBeginAllowThreads();
53913 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53914 wxPyEndAllowThreads(__tstate);
53915 if (PyErr_Occurred()) SWIG_fail;
53916 }
53917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53918 return resultobj;
53919 fail:
53920 return NULL;
53921 }
53922
53923
53924 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53925 PyObject *resultobj = 0;
53926 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53927 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
53928 wxGBSizerItem *result = 0 ;
53929 void *argp1 = 0 ;
53930 int res1 = 0 ;
53931 int res2 = 0 ;
53932 PyObject * obj0 = 0 ;
53933 PyObject * obj1 = 0 ;
53934 char * kwnames[] = {
53935 (char *) "self",(char *) "item", NULL
53936 };
53937
53938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
53939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53940 if (!SWIG_IsOK(res1)) {
53941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53942 }
53943 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53944 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53945 if (!SWIG_IsOK(res2)) {
53946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
53947 }
53948 {
53949 PyThreadState* __tstate = wxPyBeginAllowThreads();
53950 result = (wxGBSizerItem *)(arg1)->Add(arg2);
53951 wxPyEndAllowThreads(__tstate);
53952 if (PyErr_Occurred()) SWIG_fail;
53953 }
53954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53955 return resultobj;
53956 fail:
53957 return NULL;
53958 }
53959
53960
53961 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53962 PyObject *resultobj = 0;
53963 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53964 int arg2 ;
53965 int arg3 ;
53966 wxSize result;
53967 void *argp1 = 0 ;
53968 int res1 = 0 ;
53969 int val2 ;
53970 int ecode2 = 0 ;
53971 int val3 ;
53972 int ecode3 = 0 ;
53973 PyObject * obj0 = 0 ;
53974 PyObject * obj1 = 0 ;
53975 PyObject * obj2 = 0 ;
53976 char * kwnames[] = {
53977 (char *) "self",(char *) "row",(char *) "col", NULL
53978 };
53979
53980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53982 if (!SWIG_IsOK(res1)) {
53983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
53984 }
53985 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53986 ecode2 = SWIG_AsVal_int(obj1, &val2);
53987 if (!SWIG_IsOK(ecode2)) {
53988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
53989 }
53990 arg2 = static_cast< int >(val2);
53991 ecode3 = SWIG_AsVal_int(obj2, &val3);
53992 if (!SWIG_IsOK(ecode3)) {
53993 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
53994 }
53995 arg3 = static_cast< int >(val3);
53996 {
53997 PyThreadState* __tstate = wxPyBeginAllowThreads();
53998 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
53999 wxPyEndAllowThreads(__tstate);
54000 if (PyErr_Occurred()) SWIG_fail;
54001 }
54002 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54003 return resultobj;
54004 fail:
54005 return NULL;
54006 }
54007
54008
54009 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54010 PyObject *resultobj = 0;
54011 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54012 wxSize result;
54013 void *argp1 = 0 ;
54014 int res1 = 0 ;
54015 PyObject *swig_obj[1] ;
54016
54017 if (!args) SWIG_fail;
54018 swig_obj[0] = args;
54019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54020 if (!SWIG_IsOK(res1)) {
54021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54022 }
54023 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54024 {
54025 PyThreadState* __tstate = wxPyBeginAllowThreads();
54026 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
54027 wxPyEndAllowThreads(__tstate);
54028 if (PyErr_Occurred()) SWIG_fail;
54029 }
54030 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54031 return resultobj;
54032 fail:
54033 return NULL;
54034 }
54035
54036
54037 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54038 PyObject *resultobj = 0;
54039 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54040 wxSize *arg2 = 0 ;
54041 void *argp1 = 0 ;
54042 int res1 = 0 ;
54043 wxSize temp2 ;
54044 PyObject * obj0 = 0 ;
54045 PyObject * obj1 = 0 ;
54046 char * kwnames[] = {
54047 (char *) "self",(char *) "sz", NULL
54048 };
54049
54050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
54051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54052 if (!SWIG_IsOK(res1)) {
54053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54054 }
54055 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54056 {
54057 arg2 = &temp2;
54058 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
54059 }
54060 {
54061 PyThreadState* __tstate = wxPyBeginAllowThreads();
54062 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
54063 wxPyEndAllowThreads(__tstate);
54064 if (PyErr_Occurred()) SWIG_fail;
54065 }
54066 resultobj = SWIG_Py_Void();
54067 return resultobj;
54068 fail:
54069 return NULL;
54070 }
54071
54072
54073 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54074 PyObject *resultobj = 0;
54075 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54076 wxWindow *arg2 = (wxWindow *) 0 ;
54077 wxGBPosition result;
54078 void *argp1 = 0 ;
54079 int res1 = 0 ;
54080 void *argp2 = 0 ;
54081 int res2 = 0 ;
54082
54083 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54085 if (!SWIG_IsOK(res1)) {
54086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54087 }
54088 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54089 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54090 if (!SWIG_IsOK(res2)) {
54091 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54092 }
54093 arg2 = reinterpret_cast< wxWindow * >(argp2);
54094 {
54095 PyThreadState* __tstate = wxPyBeginAllowThreads();
54096 result = (arg1)->GetItemPosition(arg2);
54097 wxPyEndAllowThreads(__tstate);
54098 if (PyErr_Occurred()) SWIG_fail;
54099 }
54100 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54101 return resultobj;
54102 fail:
54103 return NULL;
54104 }
54105
54106
54107 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54108 PyObject *resultobj = 0;
54109 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54110 wxSizer *arg2 = (wxSizer *) 0 ;
54111 wxGBPosition result;
54112 void *argp1 = 0 ;
54113 int res1 = 0 ;
54114 void *argp2 = 0 ;
54115 int res2 = 0 ;
54116
54117 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54119 if (!SWIG_IsOK(res1)) {
54120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54121 }
54122 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54123 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54124 if (!SWIG_IsOK(res2)) {
54125 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54126 }
54127 arg2 = reinterpret_cast< wxSizer * >(argp2);
54128 {
54129 PyThreadState* __tstate = wxPyBeginAllowThreads();
54130 result = (arg1)->GetItemPosition(arg2);
54131 wxPyEndAllowThreads(__tstate);
54132 if (PyErr_Occurred()) SWIG_fail;
54133 }
54134 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54135 return resultobj;
54136 fail:
54137 return NULL;
54138 }
54139
54140
54141 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54142 PyObject *resultobj = 0;
54143 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54144 size_t arg2 ;
54145 wxGBPosition result;
54146 void *argp1 = 0 ;
54147 int res1 = 0 ;
54148 size_t val2 ;
54149 int ecode2 = 0 ;
54150
54151 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54153 if (!SWIG_IsOK(res1)) {
54154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54155 }
54156 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54157 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54158 if (!SWIG_IsOK(ecode2)) {
54159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54160 }
54161 arg2 = static_cast< size_t >(val2);
54162 {
54163 PyThreadState* __tstate = wxPyBeginAllowThreads();
54164 result = (arg1)->GetItemPosition(arg2);
54165 wxPyEndAllowThreads(__tstate);
54166 if (PyErr_Occurred()) SWIG_fail;
54167 }
54168 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54169 return resultobj;
54170 fail:
54171 return NULL;
54172 }
54173
54174
54175 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
54176 int argc;
54177 PyObject *argv[3];
54178
54179 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
54180 --argc;
54181 if (argc == 2) {
54182 int _v = 0;
54183 {
54184 void *vptr = 0;
54185 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54186 _v = SWIG_CheckState(res);
54187 }
54188 if (!_v) goto check_1;
54189 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
54190 }
54191 check_1:
54192
54193 if (argc == 2) {
54194 int _v = 0;
54195 {
54196 void *vptr = 0;
54197 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54198 _v = SWIG_CheckState(res);
54199 }
54200 if (!_v) goto check_2;
54201 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
54202 }
54203 check_2:
54204
54205 if (argc == 2) {
54206 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
54207 }
54208
54209 fail:
54210 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
54211 return NULL;
54212 }
54213
54214
54215 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54216 PyObject *resultobj = 0;
54217 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54218 wxWindow *arg2 = (wxWindow *) 0 ;
54219 wxGBPosition *arg3 = 0 ;
54220 bool result;
54221 void *argp1 = 0 ;
54222 int res1 = 0 ;
54223 void *argp2 = 0 ;
54224 int res2 = 0 ;
54225 wxGBPosition temp3 ;
54226
54227 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54229 if (!SWIG_IsOK(res1)) {
54230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54231 }
54232 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54233 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54234 if (!SWIG_IsOK(res2)) {
54235 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54236 }
54237 arg2 = reinterpret_cast< wxWindow * >(argp2);
54238 {
54239 arg3 = &temp3;
54240 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54241 }
54242 {
54243 PyThreadState* __tstate = wxPyBeginAllowThreads();
54244 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54245 wxPyEndAllowThreads(__tstate);
54246 if (PyErr_Occurred()) SWIG_fail;
54247 }
54248 {
54249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54250 }
54251 return resultobj;
54252 fail:
54253 return NULL;
54254 }
54255
54256
54257 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54258 PyObject *resultobj = 0;
54259 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54260 wxSizer *arg2 = (wxSizer *) 0 ;
54261 wxGBPosition *arg3 = 0 ;
54262 bool result;
54263 void *argp1 = 0 ;
54264 int res1 = 0 ;
54265 void *argp2 = 0 ;
54266 int res2 = 0 ;
54267 wxGBPosition temp3 ;
54268
54269 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54271 if (!SWIG_IsOK(res1)) {
54272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54273 }
54274 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54275 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54276 if (!SWIG_IsOK(res2)) {
54277 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54278 }
54279 arg2 = reinterpret_cast< wxSizer * >(argp2);
54280 {
54281 arg3 = &temp3;
54282 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54283 }
54284 {
54285 PyThreadState* __tstate = wxPyBeginAllowThreads();
54286 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54287 wxPyEndAllowThreads(__tstate);
54288 if (PyErr_Occurred()) SWIG_fail;
54289 }
54290 {
54291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54292 }
54293 return resultobj;
54294 fail:
54295 return NULL;
54296 }
54297
54298
54299 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54300 PyObject *resultobj = 0;
54301 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54302 size_t arg2 ;
54303 wxGBPosition *arg3 = 0 ;
54304 bool result;
54305 void *argp1 = 0 ;
54306 int res1 = 0 ;
54307 size_t val2 ;
54308 int ecode2 = 0 ;
54309 wxGBPosition temp3 ;
54310
54311 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54313 if (!SWIG_IsOK(res1)) {
54314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54315 }
54316 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54317 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54318 if (!SWIG_IsOK(ecode2)) {
54319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54320 }
54321 arg2 = static_cast< size_t >(val2);
54322 {
54323 arg3 = &temp3;
54324 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54325 }
54326 {
54327 PyThreadState* __tstate = wxPyBeginAllowThreads();
54328 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54329 wxPyEndAllowThreads(__tstate);
54330 if (PyErr_Occurred()) SWIG_fail;
54331 }
54332 {
54333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54334 }
54335 return resultobj;
54336 fail:
54337 return NULL;
54338 }
54339
54340
54341 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
54342 int argc;
54343 PyObject *argv[4];
54344
54345 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
54346 --argc;
54347 if (argc == 3) {
54348 int _v = 0;
54349 {
54350 void *vptr = 0;
54351 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54352 _v = SWIG_CheckState(res);
54353 }
54354 if (!_v) goto check_1;
54355 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
54356 }
54357 check_1:
54358
54359 if (argc == 3) {
54360 int _v = 0;
54361 {
54362 void *vptr = 0;
54363 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54364 _v = SWIG_CheckState(res);
54365 }
54366 if (!_v) goto check_2;
54367 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
54368 }
54369 check_2:
54370
54371 if (argc == 3) {
54372 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
54373 }
54374
54375 fail:
54376 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
54377 return NULL;
54378 }
54379
54380
54381 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54382 PyObject *resultobj = 0;
54383 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54384 wxWindow *arg2 = (wxWindow *) 0 ;
54385 wxGBSpan result;
54386 void *argp1 = 0 ;
54387 int res1 = 0 ;
54388 void *argp2 = 0 ;
54389 int res2 = 0 ;
54390
54391 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54393 if (!SWIG_IsOK(res1)) {
54394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54395 }
54396 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54397 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54398 if (!SWIG_IsOK(res2)) {
54399 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54400 }
54401 arg2 = reinterpret_cast< wxWindow * >(argp2);
54402 {
54403 PyThreadState* __tstate = wxPyBeginAllowThreads();
54404 result = (arg1)->GetItemSpan(arg2);
54405 wxPyEndAllowThreads(__tstate);
54406 if (PyErr_Occurred()) SWIG_fail;
54407 }
54408 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54409 return resultobj;
54410 fail:
54411 return NULL;
54412 }
54413
54414
54415 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54416 PyObject *resultobj = 0;
54417 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54418 wxSizer *arg2 = (wxSizer *) 0 ;
54419 wxGBSpan result;
54420 void *argp1 = 0 ;
54421 int res1 = 0 ;
54422 void *argp2 = 0 ;
54423 int res2 = 0 ;
54424
54425 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54427 if (!SWIG_IsOK(res1)) {
54428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54429 }
54430 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54431 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54432 if (!SWIG_IsOK(res2)) {
54433 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54434 }
54435 arg2 = reinterpret_cast< wxSizer * >(argp2);
54436 {
54437 PyThreadState* __tstate = wxPyBeginAllowThreads();
54438 result = (arg1)->GetItemSpan(arg2);
54439 wxPyEndAllowThreads(__tstate);
54440 if (PyErr_Occurred()) SWIG_fail;
54441 }
54442 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54443 return resultobj;
54444 fail:
54445 return NULL;
54446 }
54447
54448
54449 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54450 PyObject *resultobj = 0;
54451 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54452 size_t arg2 ;
54453 wxGBSpan result;
54454 void *argp1 = 0 ;
54455 int res1 = 0 ;
54456 size_t val2 ;
54457 int ecode2 = 0 ;
54458
54459 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54461 if (!SWIG_IsOK(res1)) {
54462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54463 }
54464 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54465 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54466 if (!SWIG_IsOK(ecode2)) {
54467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54468 }
54469 arg2 = static_cast< size_t >(val2);
54470 {
54471 PyThreadState* __tstate = wxPyBeginAllowThreads();
54472 result = (arg1)->GetItemSpan(arg2);
54473 wxPyEndAllowThreads(__tstate);
54474 if (PyErr_Occurred()) SWIG_fail;
54475 }
54476 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54477 return resultobj;
54478 fail:
54479 return NULL;
54480 }
54481
54482
54483 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
54484 int argc;
54485 PyObject *argv[3];
54486
54487 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
54488 --argc;
54489 if (argc == 2) {
54490 int _v = 0;
54491 {
54492 void *vptr = 0;
54493 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54494 _v = SWIG_CheckState(res);
54495 }
54496 if (!_v) goto check_1;
54497 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
54498 }
54499 check_1:
54500
54501 if (argc == 2) {
54502 int _v = 0;
54503 {
54504 void *vptr = 0;
54505 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54506 _v = SWIG_CheckState(res);
54507 }
54508 if (!_v) goto check_2;
54509 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
54510 }
54511 check_2:
54512
54513 if (argc == 2) {
54514 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
54515 }
54516
54517 fail:
54518 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
54519 return NULL;
54520 }
54521
54522
54523 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54524 PyObject *resultobj = 0;
54525 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54526 wxWindow *arg2 = (wxWindow *) 0 ;
54527 wxGBSpan *arg3 = 0 ;
54528 bool result;
54529 void *argp1 = 0 ;
54530 int res1 = 0 ;
54531 void *argp2 = 0 ;
54532 int res2 = 0 ;
54533 wxGBSpan temp3 ;
54534
54535 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54537 if (!SWIG_IsOK(res1)) {
54538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54539 }
54540 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54541 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54542 if (!SWIG_IsOK(res2)) {
54543 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54544 }
54545 arg2 = reinterpret_cast< wxWindow * >(argp2);
54546 {
54547 arg3 = &temp3;
54548 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54549 }
54550 {
54551 PyThreadState* __tstate = wxPyBeginAllowThreads();
54552 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54553 wxPyEndAllowThreads(__tstate);
54554 if (PyErr_Occurred()) SWIG_fail;
54555 }
54556 {
54557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54558 }
54559 return resultobj;
54560 fail:
54561 return NULL;
54562 }
54563
54564
54565 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54566 PyObject *resultobj = 0;
54567 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54568 wxSizer *arg2 = (wxSizer *) 0 ;
54569 wxGBSpan *arg3 = 0 ;
54570 bool result;
54571 void *argp1 = 0 ;
54572 int res1 = 0 ;
54573 void *argp2 = 0 ;
54574 int res2 = 0 ;
54575 wxGBSpan temp3 ;
54576
54577 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54579 if (!SWIG_IsOK(res1)) {
54580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54581 }
54582 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54583 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54584 if (!SWIG_IsOK(res2)) {
54585 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54586 }
54587 arg2 = reinterpret_cast< wxSizer * >(argp2);
54588 {
54589 arg3 = &temp3;
54590 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54591 }
54592 {
54593 PyThreadState* __tstate = wxPyBeginAllowThreads();
54594 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54595 wxPyEndAllowThreads(__tstate);
54596 if (PyErr_Occurred()) SWIG_fail;
54597 }
54598 {
54599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54600 }
54601 return resultobj;
54602 fail:
54603 return NULL;
54604 }
54605
54606
54607 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54608 PyObject *resultobj = 0;
54609 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54610 size_t arg2 ;
54611 wxGBSpan *arg3 = 0 ;
54612 bool result;
54613 void *argp1 = 0 ;
54614 int res1 = 0 ;
54615 size_t val2 ;
54616 int ecode2 = 0 ;
54617 wxGBSpan temp3 ;
54618
54619 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54621 if (!SWIG_IsOK(res1)) {
54622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54623 }
54624 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54625 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54626 if (!SWIG_IsOK(ecode2)) {
54627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54628 }
54629 arg2 = static_cast< size_t >(val2);
54630 {
54631 arg3 = &temp3;
54632 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54633 }
54634 {
54635 PyThreadState* __tstate = wxPyBeginAllowThreads();
54636 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54637 wxPyEndAllowThreads(__tstate);
54638 if (PyErr_Occurred()) SWIG_fail;
54639 }
54640 {
54641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54642 }
54643 return resultobj;
54644 fail:
54645 return NULL;
54646 }
54647
54648
54649 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
54650 int argc;
54651 PyObject *argv[4];
54652
54653 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
54654 --argc;
54655 if (argc == 3) {
54656 int _v = 0;
54657 {
54658 void *vptr = 0;
54659 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54660 _v = SWIG_CheckState(res);
54661 }
54662 if (!_v) goto check_1;
54663 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
54664 }
54665 check_1:
54666
54667 if (argc == 3) {
54668 int _v = 0;
54669 {
54670 void *vptr = 0;
54671 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54672 _v = SWIG_CheckState(res);
54673 }
54674 if (!_v) goto check_2;
54675 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
54676 }
54677 check_2:
54678
54679 if (argc == 3) {
54680 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
54681 }
54682
54683 fail:
54684 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
54685 return NULL;
54686 }
54687
54688
54689 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54690 PyObject *resultobj = 0;
54691 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54692 wxWindow *arg2 = (wxWindow *) 0 ;
54693 wxGBSizerItem *result = 0 ;
54694 void *argp1 = 0 ;
54695 int res1 = 0 ;
54696 void *argp2 = 0 ;
54697 int res2 = 0 ;
54698
54699 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54701 if (!SWIG_IsOK(res1)) {
54702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54703 }
54704 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54705 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54706 if (!SWIG_IsOK(res2)) {
54707 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
54708 }
54709 arg2 = reinterpret_cast< wxWindow * >(argp2);
54710 {
54711 PyThreadState* __tstate = wxPyBeginAllowThreads();
54712 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54713 wxPyEndAllowThreads(__tstate);
54714 if (PyErr_Occurred()) SWIG_fail;
54715 }
54716 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54717 return resultobj;
54718 fail:
54719 return NULL;
54720 }
54721
54722
54723 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54724 PyObject *resultobj = 0;
54725 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54726 wxSizer *arg2 = (wxSizer *) 0 ;
54727 wxGBSizerItem *result = 0 ;
54728 void *argp1 = 0 ;
54729 int res1 = 0 ;
54730 void *argp2 = 0 ;
54731 int res2 = 0 ;
54732
54733 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54735 if (!SWIG_IsOK(res1)) {
54736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54737 }
54738 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54739 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54740 if (!SWIG_IsOK(res2)) {
54741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
54742 }
54743 arg2 = reinterpret_cast< wxSizer * >(argp2);
54744 {
54745 PyThreadState* __tstate = wxPyBeginAllowThreads();
54746 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54747 wxPyEndAllowThreads(__tstate);
54748 if (PyErr_Occurred()) SWIG_fail;
54749 }
54750 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54751 return resultobj;
54752 fail:
54753 return NULL;
54754 }
54755
54756
54757 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
54758 int argc;
54759 PyObject *argv[3];
54760
54761 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
54762 --argc;
54763 if (argc == 2) {
54764 int _v = 0;
54765 {
54766 void *vptr = 0;
54767 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54768 _v = SWIG_CheckState(res);
54769 }
54770 if (!_v) goto check_1;
54771 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
54772 }
54773 check_1:
54774
54775 if (argc == 2) {
54776 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
54777 }
54778
54779 fail:
54780 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
54781 return NULL;
54782 }
54783
54784
54785 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54786 PyObject *resultobj = 0;
54787 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54788 wxGBPosition *arg2 = 0 ;
54789 wxGBSizerItem *result = 0 ;
54790 void *argp1 = 0 ;
54791 int res1 = 0 ;
54792 wxGBPosition temp2 ;
54793 PyObject * obj0 = 0 ;
54794 PyObject * obj1 = 0 ;
54795 char * kwnames[] = {
54796 (char *) "self",(char *) "pos", NULL
54797 };
54798
54799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54801 if (!SWIG_IsOK(res1)) {
54802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54803 }
54804 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54805 {
54806 arg2 = &temp2;
54807 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54808 }
54809 {
54810 PyThreadState* __tstate = wxPyBeginAllowThreads();
54811 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
54812 wxPyEndAllowThreads(__tstate);
54813 if (PyErr_Occurred()) SWIG_fail;
54814 }
54815 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54816 return resultobj;
54817 fail:
54818 return NULL;
54819 }
54820
54821
54822 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54823 PyObject *resultobj = 0;
54824 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54825 wxPoint *arg2 = 0 ;
54826 wxGBSizerItem *result = 0 ;
54827 void *argp1 = 0 ;
54828 int res1 = 0 ;
54829 wxPoint temp2 ;
54830 PyObject * obj0 = 0 ;
54831 PyObject * obj1 = 0 ;
54832 char * kwnames[] = {
54833 (char *) "self",(char *) "pt", NULL
54834 };
54835
54836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
54837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54838 if (!SWIG_IsOK(res1)) {
54839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54840 }
54841 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54842 {
54843 arg2 = &temp2;
54844 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
54845 }
54846 {
54847 PyThreadState* __tstate = wxPyBeginAllowThreads();
54848 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
54849 wxPyEndAllowThreads(__tstate);
54850 if (PyErr_Occurred()) SWIG_fail;
54851 }
54852 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54853 return resultobj;
54854 fail:
54855 return NULL;
54856 }
54857
54858
54859 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54860 PyObject *resultobj = 0;
54861 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54862 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54863 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
54864 bool result;
54865 void *argp1 = 0 ;
54866 int res1 = 0 ;
54867 void *argp2 = 0 ;
54868 int res2 = 0 ;
54869 void *argp3 = 0 ;
54870 int res3 = 0 ;
54871 PyObject * obj0 = 0 ;
54872 PyObject * obj1 = 0 ;
54873 PyObject * obj2 = 0 ;
54874 char * kwnames[] = {
54875 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
54876 };
54877
54878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54880 if (!SWIG_IsOK(res1)) {
54881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54882 }
54883 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54884 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54885 if (!SWIG_IsOK(res2)) {
54886 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54887 }
54888 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
54889 if (obj2) {
54890 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54891 if (!SWIG_IsOK(res3)) {
54892 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
54893 }
54894 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
54895 }
54896 {
54897 PyThreadState* __tstate = wxPyBeginAllowThreads();
54898 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
54899 wxPyEndAllowThreads(__tstate);
54900 if (PyErr_Occurred()) SWIG_fail;
54901 }
54902 {
54903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54904 }
54905 return resultobj;
54906 fail:
54907 return NULL;
54908 }
54909
54910
54911 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54912 PyObject *resultobj = 0;
54913 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54914 wxGBPosition *arg2 = 0 ;
54915 wxGBSpan *arg3 = 0 ;
54916 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
54917 bool result;
54918 void *argp1 = 0 ;
54919 int res1 = 0 ;
54920 wxGBPosition temp2 ;
54921 wxGBSpan temp3 ;
54922 void *argp4 = 0 ;
54923 int res4 = 0 ;
54924 PyObject * obj0 = 0 ;
54925 PyObject * obj1 = 0 ;
54926 PyObject * obj2 = 0 ;
54927 PyObject * obj3 = 0 ;
54928 char * kwnames[] = {
54929 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
54930 };
54931
54932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
54933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54934 if (!SWIG_IsOK(res1)) {
54935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54936 }
54937 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54938 {
54939 arg2 = &temp2;
54940 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54941 }
54942 {
54943 arg3 = &temp3;
54944 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54945 }
54946 if (obj3) {
54947 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54948 if (!SWIG_IsOK(res4)) {
54949 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
54950 }
54951 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
54952 }
54953 {
54954 PyThreadState* __tstate = wxPyBeginAllowThreads();
54955 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
54956 wxPyEndAllowThreads(__tstate);
54957 if (PyErr_Occurred()) SWIG_fail;
54958 }
54959 {
54960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54961 }
54962 return resultobj;
54963 fail:
54964 return NULL;
54965 }
54966
54967
54968 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54969 PyObject *obj;
54970 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54971 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
54972 return SWIG_Py_Void();
54973 }
54974
54975 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54976 return SWIG_Python_InitShadowInstance(args);
54977 }
54978
54979 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54980 PyObject *resultobj = 0;
54981 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
54982 wxRelationship arg2 ;
54983 wxWindow *arg3 = (wxWindow *) 0 ;
54984 wxEdge arg4 ;
54985 int arg5 = (int) 0 ;
54986 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
54987 void *argp1 = 0 ;
54988 int res1 = 0 ;
54989 int val2 ;
54990 int ecode2 = 0 ;
54991 void *argp3 = 0 ;
54992 int res3 = 0 ;
54993 int val4 ;
54994 int ecode4 = 0 ;
54995 int val5 ;
54996 int ecode5 = 0 ;
54997 int val6 ;
54998 int ecode6 = 0 ;
54999 PyObject * obj0 = 0 ;
55000 PyObject * obj1 = 0 ;
55001 PyObject * obj2 = 0 ;
55002 PyObject * obj3 = 0 ;
55003 PyObject * obj4 = 0 ;
55004 PyObject * obj5 = 0 ;
55005 char * kwnames[] = {
55006 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
55007 };
55008
55009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55011 if (!SWIG_IsOK(res1)) {
55012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55013 }
55014 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55015 ecode2 = SWIG_AsVal_int(obj1, &val2);
55016 if (!SWIG_IsOK(ecode2)) {
55017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
55018 }
55019 arg2 = static_cast< wxRelationship >(val2);
55020 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55021 if (!SWIG_IsOK(res3)) {
55022 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
55023 }
55024 arg3 = reinterpret_cast< wxWindow * >(argp3);
55025 ecode4 = SWIG_AsVal_int(obj3, &val4);
55026 if (!SWIG_IsOK(ecode4)) {
55027 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
55028 }
55029 arg4 = static_cast< wxEdge >(val4);
55030 if (obj4) {
55031 ecode5 = SWIG_AsVal_int(obj4, &val5);
55032 if (!SWIG_IsOK(ecode5)) {
55033 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
55034 }
55035 arg5 = static_cast< int >(val5);
55036 }
55037 if (obj5) {
55038 ecode6 = SWIG_AsVal_int(obj5, &val6);
55039 if (!SWIG_IsOK(ecode6)) {
55040 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
55041 }
55042 arg6 = static_cast< int >(val6);
55043 }
55044 {
55045 PyThreadState* __tstate = wxPyBeginAllowThreads();
55046 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
55047 wxPyEndAllowThreads(__tstate);
55048 if (PyErr_Occurred()) SWIG_fail;
55049 }
55050 resultobj = SWIG_Py_Void();
55051 return resultobj;
55052 fail:
55053 return NULL;
55054 }
55055
55056
55057 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55058 PyObject *resultobj = 0;
55059 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55060 wxWindow *arg2 = (wxWindow *) 0 ;
55061 int arg3 = (int) 0 ;
55062 void *argp1 = 0 ;
55063 int res1 = 0 ;
55064 void *argp2 = 0 ;
55065 int res2 = 0 ;
55066 int val3 ;
55067 int ecode3 = 0 ;
55068 PyObject * obj0 = 0 ;
55069 PyObject * obj1 = 0 ;
55070 PyObject * obj2 = 0 ;
55071 char * kwnames[] = {
55072 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55073 };
55074
55075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55077 if (!SWIG_IsOK(res1)) {
55078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55079 }
55080 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55081 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55082 if (!SWIG_IsOK(res2)) {
55083 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55084 }
55085 arg2 = reinterpret_cast< wxWindow * >(argp2);
55086 if (obj2) {
55087 ecode3 = SWIG_AsVal_int(obj2, &val3);
55088 if (!SWIG_IsOK(ecode3)) {
55089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
55090 }
55091 arg3 = static_cast< int >(val3);
55092 }
55093 {
55094 PyThreadState* __tstate = wxPyBeginAllowThreads();
55095 (arg1)->LeftOf(arg2,arg3);
55096 wxPyEndAllowThreads(__tstate);
55097 if (PyErr_Occurred()) SWIG_fail;
55098 }
55099 resultobj = SWIG_Py_Void();
55100 return resultobj;
55101 fail:
55102 return NULL;
55103 }
55104
55105
55106 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55107 PyObject *resultobj = 0;
55108 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55109 wxWindow *arg2 = (wxWindow *) 0 ;
55110 int arg3 = (int) 0 ;
55111 void *argp1 = 0 ;
55112 int res1 = 0 ;
55113 void *argp2 = 0 ;
55114 int res2 = 0 ;
55115 int val3 ;
55116 int ecode3 = 0 ;
55117 PyObject * obj0 = 0 ;
55118 PyObject * obj1 = 0 ;
55119 PyObject * obj2 = 0 ;
55120 char * kwnames[] = {
55121 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55122 };
55123
55124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55126 if (!SWIG_IsOK(res1)) {
55127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55128 }
55129 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55130 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55131 if (!SWIG_IsOK(res2)) {
55132 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55133 }
55134 arg2 = reinterpret_cast< wxWindow * >(argp2);
55135 if (obj2) {
55136 ecode3 = SWIG_AsVal_int(obj2, &val3);
55137 if (!SWIG_IsOK(ecode3)) {
55138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
55139 }
55140 arg3 = static_cast< int >(val3);
55141 }
55142 {
55143 PyThreadState* __tstate = wxPyBeginAllowThreads();
55144 (arg1)->RightOf(arg2,arg3);
55145 wxPyEndAllowThreads(__tstate);
55146 if (PyErr_Occurred()) SWIG_fail;
55147 }
55148 resultobj = SWIG_Py_Void();
55149 return resultobj;
55150 fail:
55151 return NULL;
55152 }
55153
55154
55155 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55156 PyObject *resultobj = 0;
55157 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55158 wxWindow *arg2 = (wxWindow *) 0 ;
55159 int arg3 = (int) 0 ;
55160 void *argp1 = 0 ;
55161 int res1 = 0 ;
55162 void *argp2 = 0 ;
55163 int res2 = 0 ;
55164 int val3 ;
55165 int ecode3 = 0 ;
55166 PyObject * obj0 = 0 ;
55167 PyObject * obj1 = 0 ;
55168 PyObject * obj2 = 0 ;
55169 char * kwnames[] = {
55170 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55171 };
55172
55173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55175 if (!SWIG_IsOK(res1)) {
55176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55177 }
55178 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55179 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55180 if (!SWIG_IsOK(res2)) {
55181 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
55182 }
55183 arg2 = reinterpret_cast< wxWindow * >(argp2);
55184 if (obj2) {
55185 ecode3 = SWIG_AsVal_int(obj2, &val3);
55186 if (!SWIG_IsOK(ecode3)) {
55187 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
55188 }
55189 arg3 = static_cast< int >(val3);
55190 }
55191 {
55192 PyThreadState* __tstate = wxPyBeginAllowThreads();
55193 (arg1)->Above(arg2,arg3);
55194 wxPyEndAllowThreads(__tstate);
55195 if (PyErr_Occurred()) SWIG_fail;
55196 }
55197 resultobj = SWIG_Py_Void();
55198 return resultobj;
55199 fail:
55200 return NULL;
55201 }
55202
55203
55204 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55205 PyObject *resultobj = 0;
55206 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55207 wxWindow *arg2 = (wxWindow *) 0 ;
55208 int arg3 = (int) 0 ;
55209 void *argp1 = 0 ;
55210 int res1 = 0 ;
55211 void *argp2 = 0 ;
55212 int res2 = 0 ;
55213 int val3 ;
55214 int ecode3 = 0 ;
55215 PyObject * obj0 = 0 ;
55216 PyObject * obj1 = 0 ;
55217 PyObject * obj2 = 0 ;
55218 char * kwnames[] = {
55219 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55220 };
55221
55222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55224 if (!SWIG_IsOK(res1)) {
55225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55226 }
55227 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55228 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55229 if (!SWIG_IsOK(res2)) {
55230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
55231 }
55232 arg2 = reinterpret_cast< wxWindow * >(argp2);
55233 if (obj2) {
55234 ecode3 = SWIG_AsVal_int(obj2, &val3);
55235 if (!SWIG_IsOK(ecode3)) {
55236 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
55237 }
55238 arg3 = static_cast< int >(val3);
55239 }
55240 {
55241 PyThreadState* __tstate = wxPyBeginAllowThreads();
55242 (arg1)->Below(arg2,arg3);
55243 wxPyEndAllowThreads(__tstate);
55244 if (PyErr_Occurred()) SWIG_fail;
55245 }
55246 resultobj = SWIG_Py_Void();
55247 return resultobj;
55248 fail:
55249 return NULL;
55250 }
55251
55252
55253 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55254 PyObject *resultobj = 0;
55255 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55256 wxWindow *arg2 = (wxWindow *) 0 ;
55257 wxEdge arg3 ;
55258 int arg4 = (int) 0 ;
55259 void *argp1 = 0 ;
55260 int res1 = 0 ;
55261 void *argp2 = 0 ;
55262 int res2 = 0 ;
55263 int val3 ;
55264 int ecode3 = 0 ;
55265 int val4 ;
55266 int ecode4 = 0 ;
55267 PyObject * obj0 = 0 ;
55268 PyObject * obj1 = 0 ;
55269 PyObject * obj2 = 0 ;
55270 PyObject * obj3 = 0 ;
55271 char * kwnames[] = {
55272 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
55273 };
55274
55275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55277 if (!SWIG_IsOK(res1)) {
55278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55279 }
55280 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55281 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55282 if (!SWIG_IsOK(res2)) {
55283 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
55284 }
55285 arg2 = reinterpret_cast< wxWindow * >(argp2);
55286 ecode3 = SWIG_AsVal_int(obj2, &val3);
55287 if (!SWIG_IsOK(ecode3)) {
55288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
55289 }
55290 arg3 = static_cast< wxEdge >(val3);
55291 if (obj3) {
55292 ecode4 = SWIG_AsVal_int(obj3, &val4);
55293 if (!SWIG_IsOK(ecode4)) {
55294 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
55295 }
55296 arg4 = static_cast< int >(val4);
55297 }
55298 {
55299 PyThreadState* __tstate = wxPyBeginAllowThreads();
55300 (arg1)->SameAs(arg2,arg3,arg4);
55301 wxPyEndAllowThreads(__tstate);
55302 if (PyErr_Occurred()) SWIG_fail;
55303 }
55304 resultobj = SWIG_Py_Void();
55305 return resultobj;
55306 fail:
55307 return NULL;
55308 }
55309
55310
55311 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55312 PyObject *resultobj = 0;
55313 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55314 wxWindow *arg2 = (wxWindow *) 0 ;
55315 wxEdge arg3 ;
55316 int arg4 ;
55317 void *argp1 = 0 ;
55318 int res1 = 0 ;
55319 void *argp2 = 0 ;
55320 int res2 = 0 ;
55321 int val3 ;
55322 int ecode3 = 0 ;
55323 int val4 ;
55324 int ecode4 = 0 ;
55325 PyObject * obj0 = 0 ;
55326 PyObject * obj1 = 0 ;
55327 PyObject * obj2 = 0 ;
55328 PyObject * obj3 = 0 ;
55329 char * kwnames[] = {
55330 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
55331 };
55332
55333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55335 if (!SWIG_IsOK(res1)) {
55336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55337 }
55338 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55339 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55340 if (!SWIG_IsOK(res2)) {
55341 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55342 }
55343 arg2 = reinterpret_cast< wxWindow * >(argp2);
55344 ecode3 = SWIG_AsVal_int(obj2, &val3);
55345 if (!SWIG_IsOK(ecode3)) {
55346 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
55347 }
55348 arg3 = static_cast< wxEdge >(val3);
55349 ecode4 = SWIG_AsVal_int(obj3, &val4);
55350 if (!SWIG_IsOK(ecode4)) {
55351 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
55352 }
55353 arg4 = static_cast< int >(val4);
55354 {
55355 PyThreadState* __tstate = wxPyBeginAllowThreads();
55356 (arg1)->PercentOf(arg2,arg3,arg4);
55357 wxPyEndAllowThreads(__tstate);
55358 if (PyErr_Occurred()) SWIG_fail;
55359 }
55360 resultobj = SWIG_Py_Void();
55361 return resultobj;
55362 fail:
55363 return NULL;
55364 }
55365
55366
55367 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55368 PyObject *resultobj = 0;
55369 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55370 int arg2 ;
55371 void *argp1 = 0 ;
55372 int res1 = 0 ;
55373 int val2 ;
55374 int ecode2 = 0 ;
55375 PyObject * obj0 = 0 ;
55376 PyObject * obj1 = 0 ;
55377 char * kwnames[] = {
55378 (char *) "self",(char *) "val", NULL
55379 };
55380
55381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
55382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55383 if (!SWIG_IsOK(res1)) {
55384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55385 }
55386 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55387 ecode2 = SWIG_AsVal_int(obj1, &val2);
55388 if (!SWIG_IsOK(ecode2)) {
55389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
55390 }
55391 arg2 = static_cast< int >(val2);
55392 {
55393 PyThreadState* __tstate = wxPyBeginAllowThreads();
55394 (arg1)->Absolute(arg2);
55395 wxPyEndAllowThreads(__tstate);
55396 if (PyErr_Occurred()) SWIG_fail;
55397 }
55398 resultobj = SWIG_Py_Void();
55399 return resultobj;
55400 fail:
55401 return NULL;
55402 }
55403
55404
55405 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55406 PyObject *resultobj = 0;
55407 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55408 void *argp1 = 0 ;
55409 int res1 = 0 ;
55410 PyObject *swig_obj[1] ;
55411
55412 if (!args) SWIG_fail;
55413 swig_obj[0] = args;
55414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55415 if (!SWIG_IsOK(res1)) {
55416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55417 }
55418 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55419 {
55420 PyThreadState* __tstate = wxPyBeginAllowThreads();
55421 (arg1)->Unconstrained();
55422 wxPyEndAllowThreads(__tstate);
55423 if (PyErr_Occurred()) SWIG_fail;
55424 }
55425 resultobj = SWIG_Py_Void();
55426 return resultobj;
55427 fail:
55428 return NULL;
55429 }
55430
55431
55432 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55433 PyObject *resultobj = 0;
55434 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55435 void *argp1 = 0 ;
55436 int res1 = 0 ;
55437 PyObject *swig_obj[1] ;
55438
55439 if (!args) SWIG_fail;
55440 swig_obj[0] = args;
55441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55442 if (!SWIG_IsOK(res1)) {
55443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55444 }
55445 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55446 {
55447 PyThreadState* __tstate = wxPyBeginAllowThreads();
55448 (arg1)->AsIs();
55449 wxPyEndAllowThreads(__tstate);
55450 if (PyErr_Occurred()) SWIG_fail;
55451 }
55452 resultobj = SWIG_Py_Void();
55453 return resultobj;
55454 fail:
55455 return NULL;
55456 }
55457
55458
55459 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55460 PyObject *resultobj = 0;
55461 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55462 wxWindow *result = 0 ;
55463 void *argp1 = 0 ;
55464 int res1 = 0 ;
55465 PyObject *swig_obj[1] ;
55466
55467 if (!args) SWIG_fail;
55468 swig_obj[0] = args;
55469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55470 if (!SWIG_IsOK(res1)) {
55471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55472 }
55473 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55474 {
55475 PyThreadState* __tstate = wxPyBeginAllowThreads();
55476 result = (wxWindow *)(arg1)->GetOtherWindow();
55477 wxPyEndAllowThreads(__tstate);
55478 if (PyErr_Occurred()) SWIG_fail;
55479 }
55480 {
55481 resultobj = wxPyMake_wxObject(result, 0);
55482 }
55483 return resultobj;
55484 fail:
55485 return NULL;
55486 }
55487
55488
55489 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55490 PyObject *resultobj = 0;
55491 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55492 wxEdge result;
55493 void *argp1 = 0 ;
55494 int res1 = 0 ;
55495 PyObject *swig_obj[1] ;
55496
55497 if (!args) SWIG_fail;
55498 swig_obj[0] = args;
55499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55500 if (!SWIG_IsOK(res1)) {
55501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55502 }
55503 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55504 {
55505 PyThreadState* __tstate = wxPyBeginAllowThreads();
55506 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
55507 wxPyEndAllowThreads(__tstate);
55508 if (PyErr_Occurred()) SWIG_fail;
55509 }
55510 resultobj = SWIG_From_int(static_cast< int >(result));
55511 return resultobj;
55512 fail:
55513 return NULL;
55514 }
55515
55516
55517 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55518 PyObject *resultobj = 0;
55519 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55520 wxEdge arg2 ;
55521 void *argp1 = 0 ;
55522 int res1 = 0 ;
55523 int val2 ;
55524 int ecode2 = 0 ;
55525 PyObject * obj0 = 0 ;
55526 PyObject * obj1 = 0 ;
55527 char * kwnames[] = {
55528 (char *) "self",(char *) "which", NULL
55529 };
55530
55531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
55532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55533 if (!SWIG_IsOK(res1)) {
55534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55535 }
55536 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55537 ecode2 = SWIG_AsVal_int(obj1, &val2);
55538 if (!SWIG_IsOK(ecode2)) {
55539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55540 }
55541 arg2 = static_cast< wxEdge >(val2);
55542 {
55543 PyThreadState* __tstate = wxPyBeginAllowThreads();
55544 (arg1)->SetEdge(arg2);
55545 wxPyEndAllowThreads(__tstate);
55546 if (PyErr_Occurred()) SWIG_fail;
55547 }
55548 resultobj = SWIG_Py_Void();
55549 return resultobj;
55550 fail:
55551 return NULL;
55552 }
55553
55554
55555 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55556 PyObject *resultobj = 0;
55557 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55558 int arg2 ;
55559 void *argp1 = 0 ;
55560 int res1 = 0 ;
55561 int val2 ;
55562 int ecode2 = 0 ;
55563 PyObject * obj0 = 0 ;
55564 PyObject * obj1 = 0 ;
55565 char * kwnames[] = {
55566 (char *) "self",(char *) "v", NULL
55567 };
55568
55569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
55570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55571 if (!SWIG_IsOK(res1)) {
55572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55573 }
55574 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55575 ecode2 = SWIG_AsVal_int(obj1, &val2);
55576 if (!SWIG_IsOK(ecode2)) {
55577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
55578 }
55579 arg2 = static_cast< int >(val2);
55580 {
55581 PyThreadState* __tstate = wxPyBeginAllowThreads();
55582 (arg1)->SetValue(arg2);
55583 wxPyEndAllowThreads(__tstate);
55584 if (PyErr_Occurred()) SWIG_fail;
55585 }
55586 resultobj = SWIG_Py_Void();
55587 return resultobj;
55588 fail:
55589 return NULL;
55590 }
55591
55592
55593 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55594 PyObject *resultobj = 0;
55595 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55596 int result;
55597 void *argp1 = 0 ;
55598 int res1 = 0 ;
55599 PyObject *swig_obj[1] ;
55600
55601 if (!args) SWIG_fail;
55602 swig_obj[0] = args;
55603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55604 if (!SWIG_IsOK(res1)) {
55605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55606 }
55607 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55608 {
55609 PyThreadState* __tstate = wxPyBeginAllowThreads();
55610 result = (int)(arg1)->GetMargin();
55611 wxPyEndAllowThreads(__tstate);
55612 if (PyErr_Occurred()) SWIG_fail;
55613 }
55614 resultobj = SWIG_From_int(static_cast< int >(result));
55615 return resultobj;
55616 fail:
55617 return NULL;
55618 }
55619
55620
55621 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55622 PyObject *resultobj = 0;
55623 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55624 int arg2 ;
55625 void *argp1 = 0 ;
55626 int res1 = 0 ;
55627 int val2 ;
55628 int ecode2 = 0 ;
55629 PyObject * obj0 = 0 ;
55630 PyObject * obj1 = 0 ;
55631 char * kwnames[] = {
55632 (char *) "self",(char *) "m", NULL
55633 };
55634
55635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
55636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55637 if (!SWIG_IsOK(res1)) {
55638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55639 }
55640 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55641 ecode2 = SWIG_AsVal_int(obj1, &val2);
55642 if (!SWIG_IsOK(ecode2)) {
55643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
55644 }
55645 arg2 = static_cast< int >(val2);
55646 {
55647 PyThreadState* __tstate = wxPyBeginAllowThreads();
55648 (arg1)->SetMargin(arg2);
55649 wxPyEndAllowThreads(__tstate);
55650 if (PyErr_Occurred()) SWIG_fail;
55651 }
55652 resultobj = SWIG_Py_Void();
55653 return resultobj;
55654 fail:
55655 return NULL;
55656 }
55657
55658
55659 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55660 PyObject *resultobj = 0;
55661 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55662 int result;
55663 void *argp1 = 0 ;
55664 int res1 = 0 ;
55665 PyObject *swig_obj[1] ;
55666
55667 if (!args) SWIG_fail;
55668 swig_obj[0] = args;
55669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55670 if (!SWIG_IsOK(res1)) {
55671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55672 }
55673 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55674 {
55675 PyThreadState* __tstate = wxPyBeginAllowThreads();
55676 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
55677 wxPyEndAllowThreads(__tstate);
55678 if (PyErr_Occurred()) SWIG_fail;
55679 }
55680 resultobj = SWIG_From_int(static_cast< int >(result));
55681 return resultobj;
55682 fail:
55683 return NULL;
55684 }
55685
55686
55687 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55688 PyObject *resultobj = 0;
55689 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55690 int result;
55691 void *argp1 = 0 ;
55692 int res1 = 0 ;
55693 PyObject *swig_obj[1] ;
55694
55695 if (!args) SWIG_fail;
55696 swig_obj[0] = args;
55697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55698 if (!SWIG_IsOK(res1)) {
55699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55700 }
55701 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55702 {
55703 PyThreadState* __tstate = wxPyBeginAllowThreads();
55704 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
55705 wxPyEndAllowThreads(__tstate);
55706 if (PyErr_Occurred()) SWIG_fail;
55707 }
55708 resultobj = SWIG_From_int(static_cast< int >(result));
55709 return resultobj;
55710 fail:
55711 return NULL;
55712 }
55713
55714
55715 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55716 PyObject *resultobj = 0;
55717 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55718 int result;
55719 void *argp1 = 0 ;
55720 int res1 = 0 ;
55721 PyObject *swig_obj[1] ;
55722
55723 if (!args) SWIG_fail;
55724 swig_obj[0] = args;
55725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55726 if (!SWIG_IsOK(res1)) {
55727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55728 }
55729 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55730 {
55731 PyThreadState* __tstate = wxPyBeginAllowThreads();
55732 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
55733 wxPyEndAllowThreads(__tstate);
55734 if (PyErr_Occurred()) SWIG_fail;
55735 }
55736 resultobj = SWIG_From_int(static_cast< int >(result));
55737 return resultobj;
55738 fail:
55739 return NULL;
55740 }
55741
55742
55743 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55744 PyObject *resultobj = 0;
55745 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55746 bool result;
55747 void *argp1 = 0 ;
55748 int res1 = 0 ;
55749 PyObject *swig_obj[1] ;
55750
55751 if (!args) SWIG_fail;
55752 swig_obj[0] = args;
55753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55754 if (!SWIG_IsOK(res1)) {
55755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55756 }
55757 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55758 {
55759 PyThreadState* __tstate = wxPyBeginAllowThreads();
55760 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
55761 wxPyEndAllowThreads(__tstate);
55762 if (PyErr_Occurred()) SWIG_fail;
55763 }
55764 {
55765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55766 }
55767 return resultobj;
55768 fail:
55769 return NULL;
55770 }
55771
55772
55773 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55774 PyObject *resultobj = 0;
55775 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55776 bool arg2 ;
55777 void *argp1 = 0 ;
55778 int res1 = 0 ;
55779 bool val2 ;
55780 int ecode2 = 0 ;
55781 PyObject * obj0 = 0 ;
55782 PyObject * obj1 = 0 ;
55783 char * kwnames[] = {
55784 (char *) "self",(char *) "d", NULL
55785 };
55786
55787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
55788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55789 if (!SWIG_IsOK(res1)) {
55790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55791 }
55792 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55793 ecode2 = SWIG_AsVal_bool(obj1, &val2);
55794 if (!SWIG_IsOK(ecode2)) {
55795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
55796 }
55797 arg2 = static_cast< bool >(val2);
55798 {
55799 PyThreadState* __tstate = wxPyBeginAllowThreads();
55800 (arg1)->SetDone(arg2);
55801 wxPyEndAllowThreads(__tstate);
55802 if (PyErr_Occurred()) SWIG_fail;
55803 }
55804 resultobj = SWIG_Py_Void();
55805 return resultobj;
55806 fail:
55807 return NULL;
55808 }
55809
55810
55811 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55812 PyObject *resultobj = 0;
55813 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55814 wxRelationship result;
55815 void *argp1 = 0 ;
55816 int res1 = 0 ;
55817 PyObject *swig_obj[1] ;
55818
55819 if (!args) SWIG_fail;
55820 swig_obj[0] = args;
55821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55822 if (!SWIG_IsOK(res1)) {
55823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55824 }
55825 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55826 {
55827 PyThreadState* __tstate = wxPyBeginAllowThreads();
55828 result = (wxRelationship)(arg1)->GetRelationship();
55829 wxPyEndAllowThreads(__tstate);
55830 if (PyErr_Occurred()) SWIG_fail;
55831 }
55832 resultobj = SWIG_From_int(static_cast< int >(result));
55833 return resultobj;
55834 fail:
55835 return NULL;
55836 }
55837
55838
55839 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55840 PyObject *resultobj = 0;
55841 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55842 wxRelationship arg2 ;
55843 void *argp1 = 0 ;
55844 int res1 = 0 ;
55845 int val2 ;
55846 int ecode2 = 0 ;
55847 PyObject * obj0 = 0 ;
55848 PyObject * obj1 = 0 ;
55849 char * kwnames[] = {
55850 (char *) "self",(char *) "r", NULL
55851 };
55852
55853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
55854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55855 if (!SWIG_IsOK(res1)) {
55856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55857 }
55858 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55859 ecode2 = SWIG_AsVal_int(obj1, &val2);
55860 if (!SWIG_IsOK(ecode2)) {
55861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
55862 }
55863 arg2 = static_cast< wxRelationship >(val2);
55864 {
55865 PyThreadState* __tstate = wxPyBeginAllowThreads();
55866 (arg1)->SetRelationship(arg2);
55867 wxPyEndAllowThreads(__tstate);
55868 if (PyErr_Occurred()) SWIG_fail;
55869 }
55870 resultobj = SWIG_Py_Void();
55871 return resultobj;
55872 fail:
55873 return NULL;
55874 }
55875
55876
55877 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55878 PyObject *resultobj = 0;
55879 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55880 wxWindow *arg2 = (wxWindow *) 0 ;
55881 bool result;
55882 void *argp1 = 0 ;
55883 int res1 = 0 ;
55884 void *argp2 = 0 ;
55885 int res2 = 0 ;
55886 PyObject * obj0 = 0 ;
55887 PyObject * obj1 = 0 ;
55888 char * kwnames[] = {
55889 (char *) "self",(char *) "otherW", NULL
55890 };
55891
55892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
55893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55894 if (!SWIG_IsOK(res1)) {
55895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55896 }
55897 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55898 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55899 if (!SWIG_IsOK(res2)) {
55900 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
55901 }
55902 arg2 = reinterpret_cast< wxWindow * >(argp2);
55903 {
55904 PyThreadState* __tstate = wxPyBeginAllowThreads();
55905 result = (bool)(arg1)->ResetIfWin(arg2);
55906 wxPyEndAllowThreads(__tstate);
55907 if (PyErr_Occurred()) SWIG_fail;
55908 }
55909 {
55910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55911 }
55912 return resultobj;
55913 fail:
55914 return NULL;
55915 }
55916
55917
55918 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55919 PyObject *resultobj = 0;
55920 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55921 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
55922 wxWindow *arg3 = (wxWindow *) 0 ;
55923 bool result;
55924 void *argp1 = 0 ;
55925 int res1 = 0 ;
55926 void *argp2 = 0 ;
55927 int res2 = 0 ;
55928 void *argp3 = 0 ;
55929 int res3 = 0 ;
55930 PyObject * obj0 = 0 ;
55931 PyObject * obj1 = 0 ;
55932 PyObject * obj2 = 0 ;
55933 char * kwnames[] = {
55934 (char *) "self",(char *) "constraints",(char *) "win", NULL
55935 };
55936
55937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55939 if (!SWIG_IsOK(res1)) {
55940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55941 }
55942 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55943 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
55944 if (!SWIG_IsOK(res2)) {
55945 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
55946 }
55947 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
55948 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55949 if (!SWIG_IsOK(res3)) {
55950 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
55951 }
55952 arg3 = reinterpret_cast< wxWindow * >(argp3);
55953 {
55954 PyThreadState* __tstate = wxPyBeginAllowThreads();
55955 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
55956 wxPyEndAllowThreads(__tstate);
55957 if (PyErr_Occurred()) SWIG_fail;
55958 }
55959 {
55960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55961 }
55962 return resultobj;
55963 fail:
55964 return NULL;
55965 }
55966
55967
55968 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55969 PyObject *resultobj = 0;
55970 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55971 wxEdge arg2 ;
55972 wxWindow *arg3 = (wxWindow *) 0 ;
55973 wxWindow *arg4 = (wxWindow *) 0 ;
55974 int result;
55975 void *argp1 = 0 ;
55976 int res1 = 0 ;
55977 int val2 ;
55978 int ecode2 = 0 ;
55979 void *argp3 = 0 ;
55980 int res3 = 0 ;
55981 void *argp4 = 0 ;
55982 int res4 = 0 ;
55983 PyObject * obj0 = 0 ;
55984 PyObject * obj1 = 0 ;
55985 PyObject * obj2 = 0 ;
55986 PyObject * obj3 = 0 ;
55987 char * kwnames[] = {
55988 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
55989 };
55990
55991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55993 if (!SWIG_IsOK(res1)) {
55994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55995 }
55996 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55997 ecode2 = SWIG_AsVal_int(obj1, &val2);
55998 if (!SWIG_IsOK(ecode2)) {
55999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
56000 }
56001 arg2 = static_cast< wxEdge >(val2);
56002 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56003 if (!SWIG_IsOK(res3)) {
56004 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
56005 }
56006 arg3 = reinterpret_cast< wxWindow * >(argp3);
56007 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
56008 if (!SWIG_IsOK(res4)) {
56009 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
56010 }
56011 arg4 = reinterpret_cast< wxWindow * >(argp4);
56012 {
56013 PyThreadState* __tstate = wxPyBeginAllowThreads();
56014 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
56015 wxPyEndAllowThreads(__tstate);
56016 if (PyErr_Occurred()) SWIG_fail;
56017 }
56018 resultobj = SWIG_From_int(static_cast< int >(result));
56019 return resultobj;
56020 fail:
56021 return NULL;
56022 }
56023
56024
56025 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56026 PyObject *obj;
56027 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56028 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
56029 return SWIG_Py_Void();
56030 }
56031
56032 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56033 PyObject *resultobj = 0;
56034 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56035 wxIndividualLayoutConstraint *result = 0 ;
56036 void *argp1 = 0 ;
56037 int res1 = 0 ;
56038 PyObject *swig_obj[1] ;
56039
56040 if (!args) SWIG_fail;
56041 swig_obj[0] = args;
56042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56043 if (!SWIG_IsOK(res1)) {
56044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56045 }
56046 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56047 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
56048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56049 return resultobj;
56050 fail:
56051 return NULL;
56052 }
56053
56054
56055 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56056 PyObject *resultobj = 0;
56057 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56058 wxIndividualLayoutConstraint *result = 0 ;
56059 void *argp1 = 0 ;
56060 int res1 = 0 ;
56061 PyObject *swig_obj[1] ;
56062
56063 if (!args) SWIG_fail;
56064 swig_obj[0] = args;
56065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56066 if (!SWIG_IsOK(res1)) {
56067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56068 }
56069 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56070 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
56071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56072 return resultobj;
56073 fail:
56074 return NULL;
56075 }
56076
56077
56078 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56079 PyObject *resultobj = 0;
56080 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56081 wxIndividualLayoutConstraint *result = 0 ;
56082 void *argp1 = 0 ;
56083 int res1 = 0 ;
56084 PyObject *swig_obj[1] ;
56085
56086 if (!args) SWIG_fail;
56087 swig_obj[0] = args;
56088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56089 if (!SWIG_IsOK(res1)) {
56090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56091 }
56092 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56093 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
56094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56095 return resultobj;
56096 fail:
56097 return NULL;
56098 }
56099
56100
56101 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56102 PyObject *resultobj = 0;
56103 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56104 wxIndividualLayoutConstraint *result = 0 ;
56105 void *argp1 = 0 ;
56106 int res1 = 0 ;
56107 PyObject *swig_obj[1] ;
56108
56109 if (!args) SWIG_fail;
56110 swig_obj[0] = args;
56111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56112 if (!SWIG_IsOK(res1)) {
56113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56114 }
56115 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56116 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
56117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56118 return resultobj;
56119 fail:
56120 return NULL;
56121 }
56122
56123
56124 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56125 PyObject *resultobj = 0;
56126 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56127 wxIndividualLayoutConstraint *result = 0 ;
56128 void *argp1 = 0 ;
56129 int res1 = 0 ;
56130 PyObject *swig_obj[1] ;
56131
56132 if (!args) SWIG_fail;
56133 swig_obj[0] = args;
56134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56135 if (!SWIG_IsOK(res1)) {
56136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56137 }
56138 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56139 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
56140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56141 return resultobj;
56142 fail:
56143 return NULL;
56144 }
56145
56146
56147 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56148 PyObject *resultobj = 0;
56149 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56150 wxIndividualLayoutConstraint *result = 0 ;
56151 void *argp1 = 0 ;
56152 int res1 = 0 ;
56153 PyObject *swig_obj[1] ;
56154
56155 if (!args) SWIG_fail;
56156 swig_obj[0] = args;
56157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56158 if (!SWIG_IsOK(res1)) {
56159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56160 }
56161 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56162 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
56163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56164 return resultobj;
56165 fail:
56166 return NULL;
56167 }
56168
56169
56170 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56171 PyObject *resultobj = 0;
56172 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56173 wxIndividualLayoutConstraint *result = 0 ;
56174 void *argp1 = 0 ;
56175 int res1 = 0 ;
56176 PyObject *swig_obj[1] ;
56177
56178 if (!args) SWIG_fail;
56179 swig_obj[0] = args;
56180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56181 if (!SWIG_IsOK(res1)) {
56182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56183 }
56184 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56185 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
56186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56187 return resultobj;
56188 fail:
56189 return NULL;
56190 }
56191
56192
56193 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56194 PyObject *resultobj = 0;
56195 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56196 wxIndividualLayoutConstraint *result = 0 ;
56197 void *argp1 = 0 ;
56198 int res1 = 0 ;
56199 PyObject *swig_obj[1] ;
56200
56201 if (!args) SWIG_fail;
56202 swig_obj[0] = args;
56203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56204 if (!SWIG_IsOK(res1)) {
56205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56206 }
56207 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56208 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
56209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56210 return resultobj;
56211 fail:
56212 return NULL;
56213 }
56214
56215
56216 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56217 PyObject *resultobj = 0;
56218 wxLayoutConstraints *result = 0 ;
56219
56220 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
56221 {
56222 PyThreadState* __tstate = wxPyBeginAllowThreads();
56223 result = (wxLayoutConstraints *)new wxLayoutConstraints();
56224 wxPyEndAllowThreads(__tstate);
56225 if (PyErr_Occurred()) SWIG_fail;
56226 }
56227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
56228 return resultobj;
56229 fail:
56230 return NULL;
56231 }
56232
56233
56234 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56235 PyObject *resultobj = 0;
56236 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56237 void *argp1 = 0 ;
56238 int res1 = 0 ;
56239 PyObject *swig_obj[1] ;
56240
56241 if (!args) SWIG_fail;
56242 swig_obj[0] = args;
56243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
56244 if (!SWIG_IsOK(res1)) {
56245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56246 }
56247 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56248 {
56249 PyThreadState* __tstate = wxPyBeginAllowThreads();
56250 delete arg1;
56251
56252 wxPyEndAllowThreads(__tstate);
56253 if (PyErr_Occurred()) SWIG_fail;
56254 }
56255 resultobj = SWIG_Py_Void();
56256 return resultobj;
56257 fail:
56258 return NULL;
56259 }
56260
56261
56262 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56263 PyObject *resultobj = 0;
56264 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56265 wxWindow *arg2 = (wxWindow *) 0 ;
56266 int *arg3 = (int *) 0 ;
56267 bool result;
56268 void *argp1 = 0 ;
56269 int res1 = 0 ;
56270 void *argp2 = 0 ;
56271 int res2 = 0 ;
56272 int temp3 ;
56273 int res3 = SWIG_TMPOBJ ;
56274 PyObject * obj0 = 0 ;
56275 PyObject * obj1 = 0 ;
56276 char * kwnames[] = {
56277 (char *) "self",(char *) "win", NULL
56278 };
56279
56280 arg3 = &temp3;
56281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
56282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56283 if (!SWIG_IsOK(res1)) {
56284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56285 }
56286 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56287 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56288 if (!SWIG_IsOK(res2)) {
56289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
56290 }
56291 arg2 = reinterpret_cast< wxWindow * >(argp2);
56292 {
56293 PyThreadState* __tstate = wxPyBeginAllowThreads();
56294 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
56295 wxPyEndAllowThreads(__tstate);
56296 if (PyErr_Occurred()) SWIG_fail;
56297 }
56298 {
56299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56300 }
56301 if (SWIG_IsTmpObj(res3)) {
56302 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
56303 } else {
56304 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
56305 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
56306 }
56307 return resultobj;
56308 fail:
56309 return NULL;
56310 }
56311
56312
56313 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56314 PyObject *resultobj = 0;
56315 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56316 bool result;
56317 void *argp1 = 0 ;
56318 int res1 = 0 ;
56319 PyObject *swig_obj[1] ;
56320
56321 if (!args) SWIG_fail;
56322 swig_obj[0] = args;
56323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56324 if (!SWIG_IsOK(res1)) {
56325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
56326 }
56327 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56328 {
56329 PyThreadState* __tstate = wxPyBeginAllowThreads();
56330 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
56331 wxPyEndAllowThreads(__tstate);
56332 if (PyErr_Occurred()) SWIG_fail;
56333 }
56334 {
56335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56336 }
56337 return resultobj;
56338 fail:
56339 return NULL;
56340 }
56341
56342
56343 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56344 PyObject *obj;
56345 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56346 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
56347 return SWIG_Py_Void();
56348 }
56349
56350 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56351 return SWIG_Python_InitShadowInstance(args);
56352 }
56353
56354 static PyMethodDef SwigMethods[] = {
56355 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
56356 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
56357 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
56358 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
56359 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
56360 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
56361 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
56362 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
56363 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
56364 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56365 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
56366 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56367 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56368 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56369 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56370 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
56371 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
56372 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
56373 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
56374 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56375 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56376 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56377 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56378 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
56379 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
56380 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
56381 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
56382 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
56383 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
56384 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
56385 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
56386 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
56387 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
56388 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
56389 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56390 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
56391 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56392 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56393 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56394 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56395 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56396 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
56397 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
56398 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
56399 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
56400 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
56401 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
56402 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
56403 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
56404 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
56405 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56406 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56407 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56408 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56409 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56410 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56411 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56412 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
56413 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
56414 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
56415 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
56416 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
56417 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
56418 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
56419 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
56420 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
56421 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
56422 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
56423 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
56424 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
56425 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56426 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
56427 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56428 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
56429 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56430 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
56431 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
56432 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
56433 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
56434 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56435 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
56436 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
56437 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
56438 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
56439 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
56440 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56441 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
56442 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
56443 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
56444 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
56445 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56446 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56447 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56448 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56449 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
56450 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
56451 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
56452 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56453 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56454 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56455 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56456 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56457 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56458 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56459 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
56460 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56461 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56462 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56463 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
56464 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
56465 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
56466 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
56467 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
56468 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
56469 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
56470 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
56471 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
56472 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56473 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
56474 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
56475 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
56476 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
56477 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
56478 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
56479 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56480 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
56481 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
56482 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
56483 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
56484 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
56485 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
56486 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
56487 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
56488 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
56489 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56490 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56491 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
56492 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56493 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56494 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
56495 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
56496 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56497 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56498 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
56499 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
56500 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
56501 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
56502 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56503 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
56504 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
56505 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
56506 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
56507 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
56508 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
56509 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
56510 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
56511 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56512 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
56513 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
56514 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56515 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56516 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
56517 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56518 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56519 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
56520 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56521 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
56522 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
56523 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
56524 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56525 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
56526 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56527 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56528 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
56529 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
56530 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56531 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
56532 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56533 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56534 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
56535 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
56536 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
56537 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
56538 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56539 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56540 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
56541 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
56542 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
56543 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56544 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
56545 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
56546 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56547 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
56548 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56549 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56550 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
56551 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
56552 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56553 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56554 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
56555 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
56556 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
56557 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
56558 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
56559 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
56560 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
56561 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
56562 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56563 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
56564 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
56565 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
56566 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
56567 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
56568 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
56569 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
56570 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
56571 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
56572 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
56573 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
56574 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
56575 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
56576 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
56577 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
56578 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
56579 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
56580 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
56581 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
56582 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
56583 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
56584 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
56585 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
56586 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
56587 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
56588 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
56589 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
56590 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
56591 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
56592 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
56593 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
56594 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
56595 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
56596 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
56597 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
56598 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
56599 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
56600 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
56601 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
56602 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56603 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56604 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56605 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56606 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
56607 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
56608 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56609 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
56610 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56611 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
56612 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
56613 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
56614 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
56615 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
56616 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
56617 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
56618 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56619 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56620 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
56621 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56622 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56623 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
56624 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
56625 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
56626 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
56627 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
56628 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
56629 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56630 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56631 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
56632 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
56633 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
56634 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56635 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56636 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56637 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
56638 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
56639 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
56640 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
56641 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56642 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
56643 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
56644 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56645 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56646 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56647 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56648 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
56649 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
56650 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
56651 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
56652 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
56653 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
56654 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
56655 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56656 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56657 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
56658 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
56659 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
56660 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
56661 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
56662 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
56663 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
56664 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
56665 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
56666 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
56667 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56668 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56669 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
56670 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56671 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
56672 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
56673 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
56674 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
56675 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
56676 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
56677 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
56678 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
56679 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
56680 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
56681 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
56682 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
56683 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
56684 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
56685 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
56686 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
56687 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
56688 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
56689 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
56690 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
56691 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
56692 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
56693 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
56694 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
56695 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
56696 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
56697 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
56698 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56699 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
56700 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56701 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
56702 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
56703 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56704 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
56705 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
56706 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
56707 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
56708 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
56709 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
56710 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
56711 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
56712 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56713 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
56714 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
56715 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
56716 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
56717 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56718 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56719 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
56720 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
56721 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
56722 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56723 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
56724 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56725 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
56726 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56727 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
56728 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
56729 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56730 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56731 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56732 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56733 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56734 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
56735 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
56736 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
56737 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
56738 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
56739 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
56740 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56741 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
56742 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
56743 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
56744 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
56745 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
56746 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56747 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
56748 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
56749 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
56750 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56751 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
56752 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
56753 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
56754 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
56755 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
56756 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
56757 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
56758 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
56759 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
56760 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
56761 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
56762 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
56763 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
56764 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56765 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56766 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56767 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56768 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
56769 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
56770 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
56771 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56772 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56773 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56774 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
56775 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
56776 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56777 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56778 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
56779 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
56780 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56781 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
56782 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
56783 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56784 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
56785 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
56786 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
56787 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
56788 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
56789 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
56790 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
56791 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
56792 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
56793 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
56794 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
56795 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
56796 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
56797 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
56798 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
56799 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
56800 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
56801 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
56802 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
56803 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
56804 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
56805 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
56806 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
56807 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
56808 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
56809 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
56810 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
56811 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
56812 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
56813 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
56814 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
56815 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
56816 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
56817 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
56818 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
56819 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
56820 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
56821 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
56822 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
56823 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
56824 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
56825 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56826 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56827 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
56828 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
56829 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56830 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56831 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
56832 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
56833 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
56834 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56835 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
56836 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
56837 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
56838 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
56839 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
56840 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
56841 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
56842 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
56843 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
56844 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
56845 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
56846 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
56847 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
56848 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
56849 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
56850 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
56851 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
56852 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
56853 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
56854 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
56855 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
56856 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
56857 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
56858 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
56859 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
56860 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
56861 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
56862 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
56863 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56864 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
56865 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
56866 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
56867 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
56868 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
56869 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
56870 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
56871 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
56872 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
56873 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
56874 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
56875 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
56876 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
56877 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
56878 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56879 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
56880 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
56881 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
56882 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
56883 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
56884 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56885 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
56886 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
56887 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56888 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56889 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
56890 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
56891 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56892 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
56893 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
56894 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56895 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56896 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
56897 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
56898 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56899 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
56900 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
56901 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
56902 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
56903 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
56904 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
56905 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
56906 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
56907 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
56908 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
56909 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
56910 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
56911 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
56912 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
56913 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
56914 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
56915 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
56916 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
56917 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
56918 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
56919 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
56920 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
56921 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
56922 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
56923 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
56924 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
56925 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
56926 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
56927 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
56928 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
56929 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56930 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
56931 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
56932 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
56933 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
56934 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
56935 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
56936 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
56937 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
56938 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
56939 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
56940 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
56941 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
56942 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
56943 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
56944 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
56945 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
56946 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
56947 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
56948 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
56949 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
56950 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
56951 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
56952 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
56953 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
56954 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
56955 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
56956 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
56957 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
56958 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
56959 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
56960 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
56961 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
56962 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56963 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
56964 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
56965 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
56966 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
56967 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
56968 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
56969 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
56970 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56971 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
56972 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
56973 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
56974 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
56975 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
56976 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
56977 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
56978 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
56979 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
56980 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56981 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
56982 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
56983 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
56984 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
56985 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
56986 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
56987 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
56988 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
56989 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
56990 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
56991 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
56992 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
56993 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
56994 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
56995 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
56996 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
56997 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
56998 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
56999 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
57000 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
57001 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
57002 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
57003 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
57004 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
57005 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
57006 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
57007 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
57008 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
57009 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57010 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
57011 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
57012 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57013 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57014 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
57015 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
57016 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
57017 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
57018 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
57019 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
57020 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57021 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
57022 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
57023 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57024 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57025 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
57026 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
57027 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57028 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
57029 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
57030 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57031 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
57032 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
57033 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57034 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
57035 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
57036 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
57037 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57038 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
57039 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57040 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
57041 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
57042 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57043 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
57044 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
57045 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
57046 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57047 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
57048 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
57049 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
57050 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57051 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
57052 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
57053 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57054 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
57055 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
57056 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
57057 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
57058 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
57059 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57060 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
57061 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
57062 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
57063 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
57064 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
57065 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
57066 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
57067 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
57068 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57069 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
57070 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
57071 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
57072 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
57073 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57074 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
57075 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
57076 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
57077 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57078 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
57079 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
57080 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
57081 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
57082 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
57083 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
57084 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57085 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
57086 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
57087 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
57088 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
57089 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
57090 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
57091 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
57092 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
57093 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57094 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57095 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57096 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57097 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
57098 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
57099 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
57100 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
57101 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57102 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
57103 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
57104 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
57105 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
57106 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
57107 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
57108 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57109 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
57110 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
57111 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
57112 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57113 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
57114 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
57115 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
57116 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
57117 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
57118 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57119 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57120 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
57121 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
57122 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
57123 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57124 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
57125 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
57126 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
57127 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
57128 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
57129 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
57130 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57131 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
57132 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
57133 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
57134 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
57135 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
57136 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
57137 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
57138 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
57139 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
57140 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57141 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
57142 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
57143 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
57144 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57145 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
57146 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
57147 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
57148 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57149 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
57150 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57151 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
57152 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
57153 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
57154 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
57155 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
57156 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57157 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
57158 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
57159 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
57160 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
57161 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57162 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
57163 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
57164 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57165 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
57166 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57167 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
57168 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
57169 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
57170 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57171 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
57172 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57173 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
57174 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
57175 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
57176 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57177 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
57178 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
57179 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
57180 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
57181 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
57182 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
57183 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57184 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
57185 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
57186 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
57187 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
57188 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
57189 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
57190 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
57191 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
57192 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
57193 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
57194 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
57195 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
57196 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
57197 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
57198 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
57199 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
57200 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
57201 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
57202 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
57203 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
57204 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57205 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
57206 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
57207 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
57208 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
57209 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
57210 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
57211 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
57212 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
57213 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
57214 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
57215 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
57216 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
57217 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
57218 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
57219 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
57220 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57221 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57222 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57223 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
57224 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
57225 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
57226 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
57227 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
57228 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
57229 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
57230 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
57231 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
57232 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
57233 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
57234 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57235 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
57236 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
57237 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
57238 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
57239 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
57240 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
57241 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
57242 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
57243 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
57244 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
57245 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
57246 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
57247 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
57248 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
57249 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
57250 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
57251 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
57252 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
57253 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
57254 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
57255 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
57256 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57257 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57258 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
57259 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
57260 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
57261 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
57262 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
57263 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
57264 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
57265 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
57266 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57267 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
57268 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
57269 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
57270 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
57271 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
57272 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
57273 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
57274 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
57275 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
57276 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
57277 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
57278 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
57279 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
57280 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
57281 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
57282 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
57283 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
57284 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57285 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
57286 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
57287 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
57288 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
57289 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57290 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
57291 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57292 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
57293 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
57294 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
57295 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57296 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
57297 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
57298 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57299 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57300 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
57301 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57302 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57303 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57304 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
57305 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57306 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57307 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
57308 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
57309 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
57310 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
57311 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
57312 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
57313 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57314 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
57315 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
57316 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
57317 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
57318 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
57319 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
57320 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
57321 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
57322 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
57323 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
57324 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
57325 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
57326 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
57327 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
57328 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
57329 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
57330 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
57331 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
57332 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
57333 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
57334 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
57335 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
57336 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57337 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57338 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57339 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57340 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
57341 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
57342 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57343 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
57344 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
57345 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
57346 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
57347 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
57348 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57349 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57350 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
57351 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
57352 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
57353 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57354 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
57355 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57356 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
57357 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
57358 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
57359 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
57360 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57361 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
57362 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57363 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
57364 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57365 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
57366 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
57367 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57368 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
57369 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
57370 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
57371 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
57372 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
57373 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
57374 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
57375 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57376 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57377 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
57378 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
57379 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
57380 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
57381 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
57382 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
57383 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
57384 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
57385 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57386 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57387 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
57388 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57389 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57390 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57391 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57392 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
57393 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
57394 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
57395 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
57396 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
57397 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
57398 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57399 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
57400 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57401 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57402 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57403 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57404 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
57405 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
57406 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57407 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57408 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
57409 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
57410 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
57411 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
57412 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
57413 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
57414 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
57415 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
57416 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
57417 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
57418 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
57419 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
57420 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
57421 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
57422 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
57423 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
57424 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
57425 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57426 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
57427 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
57428 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57429 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57430 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57431 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57432 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57433 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
57434 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
57435 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
57436 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
57437 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57438 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
57439 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
57440 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57441 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
57442 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57443 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
57444 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
57445 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
57446 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
57447 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
57448 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
57449 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57450 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57451 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
57452 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
57453 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
57454 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
57455 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
57456 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
57457 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
57458 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
57459 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
57460 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57461 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
57462 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
57463 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
57464 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
57465 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57466 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57467 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57468 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57469 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
57470 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
57471 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57472 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
57473 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
57474 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
57475 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
57476 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
57477 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
57478 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
57479 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
57480 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57481 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
57482 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
57483 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
57484 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
57485 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
57486 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
57487 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
57488 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57489 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
57490 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
57491 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
57492 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
57493 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57494 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
57495 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
57496 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57497 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
57498 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
57499 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
57500 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
57501 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
57502 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
57503 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
57504 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57505 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57506 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57507 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
57508 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
57509 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
57510 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
57511 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
57512 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
57513 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
57514 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
57515 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57516 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
57517 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
57518 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
57519 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
57520 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
57521 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57522 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
57523 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
57524 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
57525 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57526 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
57527 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57528 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57529 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57530 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57531 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
57532 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57533 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57534 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
57535 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57536 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
57537 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57538 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57539 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57540 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57541 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
57542 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57543 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57544 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57545 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57546 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
57547 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57548 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
57549 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
57550 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
57551 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
57552 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
57553 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
57554 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
57555 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57556 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57557 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57558 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57559 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57560 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57561 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57562 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57563 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57564 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57565 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
57566 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
57567 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57568 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
57569 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57570 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
57571 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
57572 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
57573 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
57574 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57575 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
57576 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
57577 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
57578 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
57579 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
57580 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
57581 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
57582 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57583 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57584 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
57585 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57586 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57587 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57588 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
57589 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
57590 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57591 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57592 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57593 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57594 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57595 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57596 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57597 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57598 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57599 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57600 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57601 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57602 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57603 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
57604 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
57605 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57606 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
57607 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
57608 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57609 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
57610 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
57611 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
57612 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57613 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
57614 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
57615 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57616 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57617 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
57618 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
57619 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57620 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
57621 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
57622 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
57623 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
57624 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
57625 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
57626 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
57627 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
57628 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57629 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
57630 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57631 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
57632 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57633 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
57634 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
57635 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
57636 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
57637 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
57638 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
57639 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57640 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
57641 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57642 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
57643 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
57644 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
57645 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57646 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
57647 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
57648 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57649 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
57650 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57651 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
57652 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
57653 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
57654 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
57655 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
57656 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
57657 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
57658 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
57659 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
57660 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57661 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
57662 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
57663 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
57664 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57665 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
57666 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
57667 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57668 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
57669 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57670 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
57671 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57672 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57673 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57674 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
57675 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
57676 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
57677 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
57678 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57679 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
57680 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57681 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
57682 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57683 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
57684 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
57685 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
57686 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
57687 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
57688 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
57689 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57690 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57691 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57692 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
57693 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
57694 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
57695 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
57696 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57697 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
57698 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
57699 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
57700 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
57701 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
57702 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
57703 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
57704 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
57705 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
57706 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
57707 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
57708 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
57709 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
57710 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57711 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
57712 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
57713 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
57714 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
57715 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57716 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
57717 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57718 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
57719 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57720 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57721 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
57722 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
57723 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
57724 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
57725 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
57726 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
57727 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
57728 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57729 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57730 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57731 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57732 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57733 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
57734 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
57735 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57736 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
57737 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57738 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
57739 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57740 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
57741 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57742 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57743 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57744 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57745 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57746 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
57747 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
57748 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
57749 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
57750 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
57751 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
57752 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
57753 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
57754 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57755 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57756 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
57757 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
57758 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
57759 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57760 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
57761 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
57762 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
57763 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
57764 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57765 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
57766 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
57767 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57768 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
57769 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57770 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
57771 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
57772 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57773 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
57774 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
57775 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
57776 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57777 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
57778 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
57779 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
57780 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
57781 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
57782 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
57783 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
57784 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
57785 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
57786 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
57787 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57788 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57789 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57790 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57791 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57792 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57793 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
57794 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
57795 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
57796 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
57797 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
57798 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
57799 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
57800 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
57801 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
57802 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
57803 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57804 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57805 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
57806 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
57807 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
57808 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
57809 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
57810 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
57811 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
57812 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
57813 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57814 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
57815 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
57816 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
57817 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
57818 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
57819 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57820 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57821 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57822 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
57823 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
57824 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
57825 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57826 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
57827 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
57828 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
57829 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
57830 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
57831 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57832 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57833 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57834 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
57835 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
57836 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
57837 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
57838 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
57839 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57840 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57841 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57842 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
57843 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
57844 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
57845 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57846 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57847 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
57848 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
57849 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
57850 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57851 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
57852 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
57853 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57854 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57855 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57856 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57857 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
57858 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57859 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
57860 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
57861 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
57862 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
57863 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
57864 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57865 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57866 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
57867 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
57868 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
57869 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
57870 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57871 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
57872 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
57873 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
57874 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
57875 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57876 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
57877 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
57878 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
57879 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
57880 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
57881 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
57882 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57883 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
57884 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
57885 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
57886 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
57887 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
57888 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
57889 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
57890 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
57891 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
57892 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
57893 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
57894 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
57895 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57896 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
57897 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
57898 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
57899 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
57900 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
57901 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
57902 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
57903 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
57904 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
57905 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
57906 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
57907 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57908 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
57909 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
57910 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
57911 { NULL, NULL, 0, NULL }
57912 };
57913
57914
57915 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
57916
57917 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
57918 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
57919 }
57920 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
57921 return (void *)((wxSizer *) ((wxBoxSizer *) x));
57922 }
57923 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
57924 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
57925 }
57926 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
57927 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
57928 }
57929 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
57930 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
57931 }
57932 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
57933 return (void *)((wxSizer *) ((wxGridSizer *) x));
57934 }
57935 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
57936 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
57937 }
57938 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
57939 return (void *)((wxSizer *) ((wxPySizer *) x));
57940 }
57941 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
57942 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
57943 }
57944 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
57945 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
57946 }
57947 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
57948 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
57949 }
57950 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
57951 return (void *)((wxEvent *) ((wxMenuEvent *) x));
57952 }
57953 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
57954 return (void *)((wxEvent *) ((wxCloseEvent *) x));
57955 }
57956 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
57957 return (void *)((wxEvent *) ((wxMouseEvent *) x));
57958 }
57959 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
57960 return (void *)((wxEvent *) ((wxEraseEvent *) x));
57961 }
57962 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
57963 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
57964 }
57965 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
57966 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
57967 }
57968 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
57969 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
57970 }
57971 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
57972 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
57973 }
57974 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
57975 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
57976 }
57977 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
57978 return (void *)((wxEvent *) ((wxPyEvent *) x));
57979 }
57980 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
57981 return (void *)((wxEvent *) ((wxIdleEvent *) x));
57982 }
57983 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
57984 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
57985 }
57986 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
57987 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
57988 }
57989 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
57990 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
57991 }
57992 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
57993 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
57994 }
57995 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
57996 return (void *)((wxEvent *) ((wxActivateEvent *) x));
57997 }
57998 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
57999 return (void *)((wxEvent *) ((wxSizeEvent *) x));
58000 }
58001 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
58002 return (void *)((wxEvent *) ((wxMoveEvent *) x));
58003 }
58004 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
58005 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
58006 }
58007 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
58008 return (void *)((wxEvent *) ((wxPaintEvent *) x));
58009 }
58010 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
58011 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
58012 }
58013 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
58014 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
58015 }
58016 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
58017 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
58018 }
58019 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
58020 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
58021 }
58022 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
58023 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
58024 }
58025 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
58026 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58027 }
58028 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
58029 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
58030 }
58031 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
58032 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
58033 }
58034 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
58035 return (void *)((wxEvent *) ((wxFocusEvent *) x));
58036 }
58037 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
58038 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
58039 }
58040 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
58041 return (void *)((wxEvent *) ((wxShowEvent *) x));
58042 }
58043 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
58044 return (void *)((wxEvent *) ((wxCommandEvent *) x));
58045 }
58046 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
58047 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
58048 }
58049 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
58050 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58051 }
58052 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
58053 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
58054 }
58055 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
58056 return (void *)((wxEvent *) ((wxKeyEvent *) x));
58057 }
58058 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
58059 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
58060 }
58061 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
58062 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
58063 }
58064 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
58065 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
58066 }
58067 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
58068 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
58069 }
58070 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
58071 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
58072 }
58073 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
58074 return (void *)((wxControl *) ((wxControlWithItems *) x));
58075 }
58076 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
58077 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
58078 }
58079 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
58080 return (void *)((wxEvtHandler *) ((wxWindow *) x));
58081 }
58082 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
58083 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58084 }
58085 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
58086 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
58087 }
58088 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
58089 return (void *)((wxEvtHandler *) ((wxValidator *) x));
58090 }
58091 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
58092 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
58093 }
58094 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
58095 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
58096 }
58097 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
58098 return (void *)((wxEvtHandler *) ((wxMenu *) x));
58099 }
58100 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
58101 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
58102 }
58103 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
58104 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
58105 }
58106 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
58107 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
58108 }
58109 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
58110 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
58111 }
58112 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
58113 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
58114 }
58115 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
58116 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58117 }
58118 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
58119 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
58120 }
58121 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
58122 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
58123 }
58124 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
58125 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
58126 }
58127 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
58128 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58129 }
58130 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
58131 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58132 }
58133 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
58134 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
58135 }
58136 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
58137 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
58138 }
58139 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
58140 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
58141 }
58142 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
58143 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
58144 }
58145 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
58146 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
58147 }
58148 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
58149 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
58150 }
58151 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
58152 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
58153 }
58154 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
58155 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
58156 }
58157 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
58158 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
58159 }
58160 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
58161 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
58162 }
58163 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
58164 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
58165 }
58166 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
58167 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
58168 }
58169 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
58170 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
58171 }
58172 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
58173 return (void *)((wxObject *) ((wxSizerItem *) x));
58174 }
58175 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
58176 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
58177 }
58178 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
58179 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
58180 }
58181 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
58182 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
58183 }
58184 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
58185 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
58186 }
58187 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
58188 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
58189 }
58190 static void *_p_wxSizerTo_p_wxObject(void *x) {
58191 return (void *)((wxObject *) ((wxSizer *) x));
58192 }
58193 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
58194 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58195 }
58196 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
58197 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
58198 }
58199 static void *_p_wxEventTo_p_wxObject(void *x) {
58200 return (void *)((wxObject *) ((wxEvent *) x));
58201 }
58202 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
58203 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
58204 }
58205 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
58206 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
58207 }
58208 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
58209 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
58210 }
58211 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
58212 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
58213 }
58214 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
58215 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
58216 }
58217 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
58218 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
58219 }
58220 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
58221 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
58222 }
58223 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
58224 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
58225 }
58226 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
58227 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58228 }
58229 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
58230 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
58231 }
58232 static void *_p_wxControlTo_p_wxObject(void *x) {
58233 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
58234 }
58235 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
58236 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
58237 }
58238 static void *_p_wxFSFileTo_p_wxObject(void *x) {
58239 return (void *)((wxObject *) ((wxFSFile *) x));
58240 }
58241 static void *_p_wxPySizerTo_p_wxObject(void *x) {
58242 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
58243 }
58244 static void *_p_wxPyEventTo_p_wxObject(void *x) {
58245 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
58246 }
58247 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
58248 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
58249 }
58250 static void *_p_wxShowEventTo_p_wxObject(void *x) {
58251 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
58252 }
58253 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
58254 return (void *)((wxObject *) ((wxMenuItem *) x));
58255 }
58256 static void *_p_wxDateEventTo_p_wxObject(void *x) {
58257 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
58258 }
58259 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
58260 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
58261 }
58262 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
58263 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
58264 }
58265 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
58266 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
58267 }
58268 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
58269 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
58270 }
58271 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
58272 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
58273 }
58274 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
58275 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
58276 }
58277 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
58278 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
58279 }
58280 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
58281 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
58282 }
58283 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
58284 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
58285 }
58286 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
58287 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
58288 }
58289 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
58290 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
58291 }
58292 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
58293 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
58294 }
58295 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
58296 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
58297 }
58298 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
58299 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58300 }
58301 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
58302 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58303 }
58304 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
58305 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
58306 }
58307 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
58308 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
58309 }
58310 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
58311 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
58312 }
58313 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
58314 return (void *)((wxObject *) ((wxImageHandler *) x));
58315 }
58316 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
58317 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
58318 }
58319 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
58320 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
58321 }
58322 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
58323 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
58324 }
58325 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
58326 return (void *)((wxObject *) ((wxEvtHandler *) x));
58327 }
58328 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
58329 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
58330 }
58331 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
58332 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
58333 }
58334 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
58335 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58336 }
58337 static void *_p_wxImageTo_p_wxObject(void *x) {
58338 return (void *)((wxObject *) ((wxImage *) x));
58339 }
58340 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
58341 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
58342 }
58343 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
58344 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58345 }
58346 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
58347 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
58348 }
58349 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
58350 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
58351 }
58352 static void *_p_wxWindowTo_p_wxObject(void *x) {
58353 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
58354 }
58355 static void *_p_wxMenuTo_p_wxObject(void *x) {
58356 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
58357 }
58358 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
58359 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
58360 }
58361 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
58362 return (void *)((wxObject *) ((wxFileSystem *) x));
58363 }
58364 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
58365 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
58366 }
58367 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
58368 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
58369 }
58370 static void *_p_wxPyAppTo_p_wxObject(void *x) {
58371 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
58372 }
58373 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
58374 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
58375 }
58376 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
58377 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
58378 }
58379 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
58380 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
58381 }
58382 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
58383 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
58384 }
58385 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
58386 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
58387 }
58388 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
58389 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
58390 }
58391 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
58392 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
58393 }
58394 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
58395 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
58396 }
58397 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
58398 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58399 }
58400 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
58401 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
58402 }
58403 static void *_p_wxValidatorTo_p_wxObject(void *x) {
58404 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
58405 }
58406 static void *_p_wxControlTo_p_wxWindow(void *x) {
58407 return (void *)((wxWindow *) ((wxControl *) x));
58408 }
58409 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
58410 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
58411 }
58412 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
58413 return (void *)((wxWindow *) ((wxMenuBar *) x));
58414 }
58415 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
58416 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
58417 }
58418 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
58419 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
58420 }
58421 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
58422 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
58423 }
58424 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
58425 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
58426 }
58427 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
58428 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
58429 }
58430 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
58431 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
58432 }
58433 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
58434 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58435 }
58436 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
58437 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
58438 }
58439 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
58440 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
58441 }
58442 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
58443 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
58444 }
58445 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
58446 return (void *)((wxValidator *) ((wxPyValidator *) x));
58447 }
58448 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
58449 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
58450 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};
58451 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
58452 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
58453 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
58454 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
58455 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
58456 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
58457 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
58458 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
58459 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
58460 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
58461 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
58462 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
58463 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
58464 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
58465 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
58466 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
58467 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
58468 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
58469 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
58470 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
58471 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
58472 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
58473 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
58474 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
58475 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
58476 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
58477 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
58478 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
58479 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
58480 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
58481 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
58482 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
58483 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
58484 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
58485 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
58486 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
58487 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
58488 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
58489 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
58490 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
58491 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
58492 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
58493 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
58494 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
58495 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
58496 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
58497 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
58498 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
58499 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
58500 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
58501 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
58502 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
58503 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
58504 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
58505 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
58506 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
58507 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
58508 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
58509 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
58510 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
58511 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
58512 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
58513 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
58514 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
58515 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
58516 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
58517 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
58518 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
58519 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
58520 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
58521 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
58522 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
58523 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
58524 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
58525 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
58526 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
58527 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
58528 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
58529 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
58530 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
58531 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
58532 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
58533 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
58534 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
58535 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
58536 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
58537 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
58538 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
58539 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
58540 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
58541 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
58542 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
58543 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
58544 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
58545 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
58546 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
58547 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
58548 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
58549 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
58550 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
58551 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
58552 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
58553 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
58554 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
58555 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
58556 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
58557 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
58558 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
58559 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
58560 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
58561 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
58562 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
58563 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
58564 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
58565 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
58566 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
58567 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
58568 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
58569 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
58570 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
58571 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
58572 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
58573 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
58574 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
58575 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
58576 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
58577 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
58578 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
58579 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
58580 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
58581 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
58582 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
58583
58584 static swig_type_info *swig_type_initial[] = {
58585 &_swigt__p_buffer,
58586 &_swigt__p_char,
58587 &_swigt__p_form_ops_t,
58588 &_swigt__p_int,
58589 &_swigt__p_long,
58590 &_swigt__p_unsigned_char,
58591 &_swigt__p_unsigned_int,
58592 &_swigt__p_unsigned_long,
58593 &_swigt__p_wxANIHandler,
58594 &_swigt__p_wxAcceleratorEntry,
58595 &_swigt__p_wxAcceleratorTable,
58596 &_swigt__p_wxActivateEvent,
58597 &_swigt__p_wxAppTraits,
58598 &_swigt__p_wxArrayString,
58599 &_swigt__p_wxBMPHandler,
58600 &_swigt__p_wxBitmap,
58601 &_swigt__p_wxBoxSizer,
58602 &_swigt__p_wxButton,
58603 &_swigt__p_wxCURHandler,
58604 &_swigt__p_wxCaret,
58605 &_swigt__p_wxChildFocusEvent,
58606 &_swigt__p_wxClipboardTextEvent,
58607 &_swigt__p_wxCloseEvent,
58608 &_swigt__p_wxColour,
58609 &_swigt__p_wxCommandEvent,
58610 &_swigt__p_wxContextMenuEvent,
58611 &_swigt__p_wxControl,
58612 &_swigt__p_wxControlWithItems,
58613 &_swigt__p_wxCursor,
58614 &_swigt__p_wxDC,
58615 &_swigt__p_wxDateEvent,
58616 &_swigt__p_wxDateTime,
58617 &_swigt__p_wxDisplayChangedEvent,
58618 &_swigt__p_wxDouble,
58619 &_swigt__p_wxDropFilesEvent,
58620 &_swigt__p_wxDuplexMode,
58621 &_swigt__p_wxEraseEvent,
58622 &_swigt__p_wxEvent,
58623 &_swigt__p_wxEventLoop,
58624 &_swigt__p_wxEventLoopActivator,
58625 &_swigt__p_wxEvtHandler,
58626 &_swigt__p_wxFSFile,
58627 &_swigt__p_wxFileSystem,
58628 &_swigt__p_wxFileSystemHandler,
58629 &_swigt__p_wxFlexGridSizer,
58630 &_swigt__p_wxFocusEvent,
58631 &_swigt__p_wxFont,
58632 &_swigt__p_wxFrame,
58633 &_swigt__p_wxGBPosition,
58634 &_swigt__p_wxGBSizerItem,
58635 &_swigt__p_wxGBSpan,
58636 &_swigt__p_wxGIFHandler,
58637 &_swigt__p_wxGridBagSizer,
58638 &_swigt__p_wxGridSizer,
58639 &_swigt__p_wxHelpEvent__Origin,
58640 &_swigt__p_wxICOHandler,
58641 &_swigt__p_wxIconizeEvent,
58642 &_swigt__p_wxIdleEvent,
58643 &_swigt__p_wxImage,
58644 &_swigt__p_wxImageHandler,
58645 &_swigt__p_wxImageHistogram,
58646 &_swigt__p_wxImage_HSVValue,
58647 &_swigt__p_wxImage_RGBValue,
58648 &_swigt__p_wxIndividualLayoutConstraint,
58649 &_swigt__p_wxInitDialogEvent,
58650 &_swigt__p_wxInputStream,
58651 &_swigt__p_wxInternetFSHandler,
58652 &_swigt__p_wxItemContainer,
58653 &_swigt__p_wxJPEGHandler,
58654 &_swigt__p_wxKeyEvent,
58655 &_swigt__p_wxLayoutConstraints,
58656 &_swigt__p_wxMaximizeEvent,
58657 &_swigt__p_wxMemoryFSHandler,
58658 &_swigt__p_wxMenu,
58659 &_swigt__p_wxMenuBar,
58660 &_swigt__p_wxMenuBarBase,
58661 &_swigt__p_wxMenuEvent,
58662 &_swigt__p_wxMenuItem,
58663 &_swigt__p_wxMouseCaptureChangedEvent,
58664 &_swigt__p_wxMouseCaptureLostEvent,
58665 &_swigt__p_wxMouseEvent,
58666 &_swigt__p_wxMoveEvent,
58667 &_swigt__p_wxNavigationKeyEvent,
58668 &_swigt__p_wxNcPaintEvent,
58669 &_swigt__p_wxNotifyEvent,
58670 &_swigt__p_wxObject,
58671 &_swigt__p_wxOutputStream,
58672 &_swigt__p_wxPCXHandler,
58673 &_swigt__p_wxPNGHandler,
58674 &_swigt__p_wxPNMHandler,
58675 &_swigt__p_wxPaintEvent,
58676 &_swigt__p_wxPaletteChangedEvent,
58677 &_swigt__p_wxPaperSize,
58678 &_swigt__p_wxPoint,
58679 &_swigt__p_wxPoint2D,
58680 &_swigt__p_wxPropagateOnce,
58681 &_swigt__p_wxPropagationDisabler,
58682 &_swigt__p_wxPyApp,
58683 &_swigt__p_wxPyCommandEvent,
58684 &_swigt__p_wxPyDropTarget,
58685 &_swigt__p_wxPyEvent,
58686 &_swigt__p_wxPyFileSystemHandler,
58687 &_swigt__p_wxPyImageHandler,
58688 &_swigt__p_wxPyInputStream,
58689 &_swigt__p_wxPySizer,
58690 &_swigt__p_wxPyValidator,
58691 &_swigt__p_wxQuantize,
58692 &_swigt__p_wxQueryNewPaletteEvent,
58693 &_swigt__p_wxRealPoint,
58694 &_swigt__p_wxRect,
58695 &_swigt__p_wxRect2D,
58696 &_swigt__p_wxRegion,
58697 &_swigt__p_wxScrollEvent,
58698 &_swigt__p_wxScrollWinEvent,
58699 &_swigt__p_wxSetCursorEvent,
58700 &_swigt__p_wxShowEvent,
58701 &_swigt__p_wxSize,
58702 &_swigt__p_wxSizeEvent,
58703 &_swigt__p_wxSizer,
58704 &_swigt__p_wxSizerItem,
58705 &_swigt__p_wxStaticBox,
58706 &_swigt__p_wxStaticBoxSizer,
58707 &_swigt__p_wxStdDialogButtonSizer,
58708 &_swigt__p_wxSysColourChangedEvent,
58709 &_swigt__p_wxTGAHandler,
58710 &_swigt__p_wxTIFFHandler,
58711 &_swigt__p_wxToolTip,
58712 &_swigt__p_wxUpdateUIEvent,
58713 &_swigt__p_wxValidator,
58714 &_swigt__p_wxVisualAttributes,
58715 &_swigt__p_wxWindow,
58716 &_swigt__p_wxWindowCreateEvent,
58717 &_swigt__p_wxWindowDestroyEvent,
58718 &_swigt__p_wxXPMHandler,
58719 &_swigt__p_wxZipFSHandler,
58720 };
58721
58722 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
58723 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
58724 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
58725 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
58726 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
58727 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
58728 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
58729 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
58730 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
58731 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
58732 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
58733 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
58734 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
58735 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
58736 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}};
58737 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
58738 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}};
58739 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
58740 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}};
58741 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
58742 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58743 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
58744 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
58745 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
58746 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
58747 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58748 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}};
58749 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
58750 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
58751 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
58752 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
58753 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
58754 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58755 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
58756 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
58757 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
58758 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
58759 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
58760 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
58761 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
58762 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}};
58763 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
58764 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
58765 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}};
58766 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}};
58767 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58768 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
58769 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
58770 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
58771 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
58772 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
58773 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
58774 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
58775 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}};
58776 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
58777 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}};
58778 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58779 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
58780 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
58781 static swig_cast_info _swigc__p_wxImageHandler[] = { {&_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}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58782 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
58783 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
58784 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
58785 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
58786 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
58787 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
58788 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58789 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}};
58790 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
58791 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58792 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
58793 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58794 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58795 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
58796 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
58797 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
58798 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58799 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
58800 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58801 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
58802 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
58803 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
58804 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58805 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58806 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
58807 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_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_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_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_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
58808 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
58809 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
58810 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
58811 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
58812 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58813 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58814 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
58815 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
58816 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
58817 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
58818 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
58819 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
58820 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
58821 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
58822 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
58823 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
58824 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58825 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
58826 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
58827 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
58828 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
58829 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
58830 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
58831 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
58832 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
58833 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
58834 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
58835 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
58836 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
58837 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
58838 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
58839 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58840 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}};
58841 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}};
58842 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
58843 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
58844 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
58845 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58846 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
58847 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
58848 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
58849 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
58850 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}};
58851 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
58852 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}};
58853 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
58854 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
58855 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
58856 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58857
58858 static swig_cast_info *swig_cast_initial[] = {
58859 _swigc__p_buffer,
58860 _swigc__p_char,
58861 _swigc__p_form_ops_t,
58862 _swigc__p_int,
58863 _swigc__p_long,
58864 _swigc__p_unsigned_char,
58865 _swigc__p_unsigned_int,
58866 _swigc__p_unsigned_long,
58867 _swigc__p_wxANIHandler,
58868 _swigc__p_wxAcceleratorEntry,
58869 _swigc__p_wxAcceleratorTable,
58870 _swigc__p_wxActivateEvent,
58871 _swigc__p_wxAppTraits,
58872 _swigc__p_wxArrayString,
58873 _swigc__p_wxBMPHandler,
58874 _swigc__p_wxBitmap,
58875 _swigc__p_wxBoxSizer,
58876 _swigc__p_wxButton,
58877 _swigc__p_wxCURHandler,
58878 _swigc__p_wxCaret,
58879 _swigc__p_wxChildFocusEvent,
58880 _swigc__p_wxClipboardTextEvent,
58881 _swigc__p_wxCloseEvent,
58882 _swigc__p_wxColour,
58883 _swigc__p_wxCommandEvent,
58884 _swigc__p_wxContextMenuEvent,
58885 _swigc__p_wxControl,
58886 _swigc__p_wxControlWithItems,
58887 _swigc__p_wxCursor,
58888 _swigc__p_wxDC,
58889 _swigc__p_wxDateEvent,
58890 _swigc__p_wxDateTime,
58891 _swigc__p_wxDisplayChangedEvent,
58892 _swigc__p_wxDouble,
58893 _swigc__p_wxDropFilesEvent,
58894 _swigc__p_wxDuplexMode,
58895 _swigc__p_wxEraseEvent,
58896 _swigc__p_wxEvent,
58897 _swigc__p_wxEventLoop,
58898 _swigc__p_wxEventLoopActivator,
58899 _swigc__p_wxEvtHandler,
58900 _swigc__p_wxFSFile,
58901 _swigc__p_wxFileSystem,
58902 _swigc__p_wxFileSystemHandler,
58903 _swigc__p_wxFlexGridSizer,
58904 _swigc__p_wxFocusEvent,
58905 _swigc__p_wxFont,
58906 _swigc__p_wxFrame,
58907 _swigc__p_wxGBPosition,
58908 _swigc__p_wxGBSizerItem,
58909 _swigc__p_wxGBSpan,
58910 _swigc__p_wxGIFHandler,
58911 _swigc__p_wxGridBagSizer,
58912 _swigc__p_wxGridSizer,
58913 _swigc__p_wxHelpEvent__Origin,
58914 _swigc__p_wxICOHandler,
58915 _swigc__p_wxIconizeEvent,
58916 _swigc__p_wxIdleEvent,
58917 _swigc__p_wxImage,
58918 _swigc__p_wxImageHandler,
58919 _swigc__p_wxImageHistogram,
58920 _swigc__p_wxImage_HSVValue,
58921 _swigc__p_wxImage_RGBValue,
58922 _swigc__p_wxIndividualLayoutConstraint,
58923 _swigc__p_wxInitDialogEvent,
58924 _swigc__p_wxInputStream,
58925 _swigc__p_wxInternetFSHandler,
58926 _swigc__p_wxItemContainer,
58927 _swigc__p_wxJPEGHandler,
58928 _swigc__p_wxKeyEvent,
58929 _swigc__p_wxLayoutConstraints,
58930 _swigc__p_wxMaximizeEvent,
58931 _swigc__p_wxMemoryFSHandler,
58932 _swigc__p_wxMenu,
58933 _swigc__p_wxMenuBar,
58934 _swigc__p_wxMenuBarBase,
58935 _swigc__p_wxMenuEvent,
58936 _swigc__p_wxMenuItem,
58937 _swigc__p_wxMouseCaptureChangedEvent,
58938 _swigc__p_wxMouseCaptureLostEvent,
58939 _swigc__p_wxMouseEvent,
58940 _swigc__p_wxMoveEvent,
58941 _swigc__p_wxNavigationKeyEvent,
58942 _swigc__p_wxNcPaintEvent,
58943 _swigc__p_wxNotifyEvent,
58944 _swigc__p_wxObject,
58945 _swigc__p_wxOutputStream,
58946 _swigc__p_wxPCXHandler,
58947 _swigc__p_wxPNGHandler,
58948 _swigc__p_wxPNMHandler,
58949 _swigc__p_wxPaintEvent,
58950 _swigc__p_wxPaletteChangedEvent,
58951 _swigc__p_wxPaperSize,
58952 _swigc__p_wxPoint,
58953 _swigc__p_wxPoint2D,
58954 _swigc__p_wxPropagateOnce,
58955 _swigc__p_wxPropagationDisabler,
58956 _swigc__p_wxPyApp,
58957 _swigc__p_wxPyCommandEvent,
58958 _swigc__p_wxPyDropTarget,
58959 _swigc__p_wxPyEvent,
58960 _swigc__p_wxPyFileSystemHandler,
58961 _swigc__p_wxPyImageHandler,
58962 _swigc__p_wxPyInputStream,
58963 _swigc__p_wxPySizer,
58964 _swigc__p_wxPyValidator,
58965 _swigc__p_wxQuantize,
58966 _swigc__p_wxQueryNewPaletteEvent,
58967 _swigc__p_wxRealPoint,
58968 _swigc__p_wxRect,
58969 _swigc__p_wxRect2D,
58970 _swigc__p_wxRegion,
58971 _swigc__p_wxScrollEvent,
58972 _swigc__p_wxScrollWinEvent,
58973 _swigc__p_wxSetCursorEvent,
58974 _swigc__p_wxShowEvent,
58975 _swigc__p_wxSize,
58976 _swigc__p_wxSizeEvent,
58977 _swigc__p_wxSizer,
58978 _swigc__p_wxSizerItem,
58979 _swigc__p_wxStaticBox,
58980 _swigc__p_wxStaticBoxSizer,
58981 _swigc__p_wxStdDialogButtonSizer,
58982 _swigc__p_wxSysColourChangedEvent,
58983 _swigc__p_wxTGAHandler,
58984 _swigc__p_wxTIFFHandler,
58985 _swigc__p_wxToolTip,
58986 _swigc__p_wxUpdateUIEvent,
58987 _swigc__p_wxValidator,
58988 _swigc__p_wxVisualAttributes,
58989 _swigc__p_wxWindow,
58990 _swigc__p_wxWindowCreateEvent,
58991 _swigc__p_wxWindowDestroyEvent,
58992 _swigc__p_wxXPMHandler,
58993 _swigc__p_wxZipFSHandler,
58994 };
58995
58996
58997 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
58998
58999 static swig_const_info swig_const_table[] = {
59000 {0, 0, 0, 0.0, 0, 0}};
59001
59002 #ifdef __cplusplus
59003 }
59004 #endif
59005 /* -----------------------------------------------------------------------------
59006 * Type initialization:
59007 * This problem is tough by the requirement that no dynamic
59008 * memory is used. Also, since swig_type_info structures store pointers to
59009 * swig_cast_info structures and swig_cast_info structures store pointers back
59010 * to swig_type_info structures, we need some lookup code at initialization.
59011 * The idea is that swig generates all the structures that are needed.
59012 * The runtime then collects these partially filled structures.
59013 * The SWIG_InitializeModule function takes these initial arrays out of
59014 * swig_module, and does all the lookup, filling in the swig_module.types
59015 * array with the correct data and linking the correct swig_cast_info
59016 * structures together.
59017 *
59018 * The generated swig_type_info structures are assigned staticly to an initial
59019 * array. We just loop though that array, and handle each type individually.
59020 * First we lookup if this type has been already loaded, and if so, use the
59021 * loaded structure instead of the generated one. Then we have to fill in the
59022 * cast linked list. The cast data is initially stored in something like a
59023 * two-dimensional array. Each row corresponds to a type (there are the same
59024 * number of rows as there are in the swig_type_initial array). Each entry in
59025 * a column is one of the swig_cast_info structures for that type.
59026 * The cast_initial array is actually an array of arrays, because each row has
59027 * a variable number of columns. So to actually build the cast linked list,
59028 * we find the array of casts associated with the type, and loop through it
59029 * adding the casts to the list. The one last trick we need to do is making
59030 * sure the type pointer in the swig_cast_info struct is correct.
59031 *
59032 * First off, we lookup the cast->type name to see if it is already loaded.
59033 * There are three cases to handle:
59034 * 1) If the cast->type has already been loaded AND the type we are adding
59035 * casting info to has not been loaded (it is in this module), THEN we
59036 * replace the cast->type pointer with the type pointer that has already
59037 * been loaded.
59038 * 2) If BOTH types (the one we are adding casting info to, and the
59039 * cast->type) are loaded, THEN the cast info has already been loaded by
59040 * the previous module so we just ignore it.
59041 * 3) Finally, if cast->type has not already been loaded, then we add that
59042 * swig_cast_info to the linked list (because the cast->type) pointer will
59043 * be correct.
59044 * ----------------------------------------------------------------------------- */
59045
59046 #ifdef __cplusplus
59047 extern "C" {
59048 #if 0
59049 } /* c-mode */
59050 #endif
59051 #endif
59052
59053 #if 0
59054 #define SWIGRUNTIME_DEBUG
59055 #endif
59056
59057 SWIGRUNTIME void
59058 SWIG_InitializeModule(void *clientdata) {
59059 size_t i;
59060 swig_module_info *module_head;
59061 static int init_run = 0;
59062
59063 clientdata = clientdata;
59064
59065 if (init_run) return;
59066 init_run = 1;
59067
59068 /* Initialize the swig_module */
59069 swig_module.type_initial = swig_type_initial;
59070 swig_module.cast_initial = swig_cast_initial;
59071
59072 /* Try and load any already created modules */
59073 module_head = SWIG_GetModule(clientdata);
59074 if (module_head) {
59075 swig_module.next = module_head->next;
59076 module_head->next = &swig_module;
59077 } else {
59078 /* This is the first module loaded */
59079 swig_module.next = &swig_module;
59080 SWIG_SetModule(clientdata, &swig_module);
59081 }
59082
59083 /* Now work on filling in swig_module.types */
59084 #ifdef SWIGRUNTIME_DEBUG
59085 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
59086 #endif
59087 for (i = 0; i < swig_module.size; ++i) {
59088 swig_type_info *type = 0;
59089 swig_type_info *ret;
59090 swig_cast_info *cast;
59091
59092 #ifdef SWIGRUNTIME_DEBUG
59093 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59094 #endif
59095
59096 /* if there is another module already loaded */
59097 if (swig_module.next != &swig_module) {
59098 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
59099 }
59100 if (type) {
59101 /* Overwrite clientdata field */
59102 #ifdef SWIGRUNTIME_DEBUG
59103 printf("SWIG_InitializeModule: found type %s\n", type->name);
59104 #endif
59105 if (swig_module.type_initial[i]->clientdata) {
59106 type->clientdata = swig_module.type_initial[i]->clientdata;
59107 #ifdef SWIGRUNTIME_DEBUG
59108 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
59109 #endif
59110 }
59111 } else {
59112 type = swig_module.type_initial[i];
59113 }
59114
59115 /* Insert casting types */
59116 cast = swig_module.cast_initial[i];
59117 while (cast->type) {
59118 /* Don't need to add information already in the list */
59119 ret = 0;
59120 #ifdef SWIGRUNTIME_DEBUG
59121 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
59122 #endif
59123 if (swig_module.next != &swig_module) {
59124 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
59125 #ifdef SWIGRUNTIME_DEBUG
59126 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
59127 #endif
59128 }
59129 if (ret) {
59130 if (type == swig_module.type_initial[i]) {
59131 #ifdef SWIGRUNTIME_DEBUG
59132 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
59133 #endif
59134 cast->type = ret;
59135 ret = 0;
59136 } else {
59137 /* Check for casting already in the list */
59138 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
59139 #ifdef SWIGRUNTIME_DEBUG
59140 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
59141 #endif
59142 if (!ocast) ret = 0;
59143 }
59144 }
59145
59146 if (!ret) {
59147 #ifdef SWIGRUNTIME_DEBUG
59148 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
59149 #endif
59150 if (type->cast) {
59151 type->cast->prev = cast;
59152 cast->next = type->cast;
59153 }
59154 type->cast = cast;
59155 }
59156 cast++;
59157 }
59158 /* Set entry in modules->types array equal to the type */
59159 swig_module.types[i] = type;
59160 }
59161 swig_module.types[i] = 0;
59162
59163 #ifdef SWIGRUNTIME_DEBUG
59164 printf("**** SWIG_InitializeModule: Cast List ******\n");
59165 for (i = 0; i < swig_module.size; ++i) {
59166 int j = 0;
59167 swig_cast_info *cast = swig_module.cast_initial[i];
59168 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59169 while (cast->type) {
59170 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
59171 cast++;
59172 ++j;
59173 }
59174 printf("---- Total casts: %d\n",j);
59175 }
59176 printf("**** SWIG_InitializeModule: Cast List ******\n");
59177 #endif
59178 }
59179
59180 /* This function will propagate the clientdata field of type to
59181 * any new swig_type_info structures that have been added into the list
59182 * of equivalent types. It is like calling
59183 * SWIG_TypeClientData(type, clientdata) a second time.
59184 */
59185 SWIGRUNTIME void
59186 SWIG_PropagateClientData(void) {
59187 size_t i;
59188 swig_cast_info *equiv;
59189 static int init_run = 0;
59190
59191 if (init_run) return;
59192 init_run = 1;
59193
59194 for (i = 0; i < swig_module.size; i++) {
59195 if (swig_module.types[i]->clientdata) {
59196 equiv = swig_module.types[i]->cast;
59197 while (equiv) {
59198 if (!equiv->converter) {
59199 if (equiv->type && !equiv->type->clientdata)
59200 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
59201 }
59202 equiv = equiv->next;
59203 }
59204 }
59205 }
59206 }
59207
59208 #ifdef __cplusplus
59209 #if 0
59210 {
59211 /* c-mode */
59212 #endif
59213 }
59214 #endif
59215
59216
59217
59218 #ifdef __cplusplus
59219 extern "C" {
59220 #endif
59221
59222 /* Python-specific SWIG API */
59223 #define SWIG_newvarlink() SWIG_Python_newvarlink()
59224 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
59225 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
59226
59227 /* -----------------------------------------------------------------------------
59228 * global variable support code.
59229 * ----------------------------------------------------------------------------- */
59230
59231 typedef struct swig_globalvar {
59232 char *name; /* Name of global variable */
59233 PyObject *(*get_attr)(void); /* Return the current value */
59234 int (*set_attr)(PyObject *); /* Set the value */
59235 struct swig_globalvar *next;
59236 } swig_globalvar;
59237
59238 typedef struct swig_varlinkobject {
59239 PyObject_HEAD
59240 swig_globalvar *vars;
59241 } swig_varlinkobject;
59242
59243 SWIGINTERN PyObject *
59244 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
59245 return PyString_FromString("<Swig global variables>");
59246 }
59247
59248 SWIGINTERN PyObject *
59249 swig_varlink_str(swig_varlinkobject *v) {
59250 PyObject *str = PyString_FromString("(");
59251 swig_globalvar *var;
59252 for (var = v->vars; var; var=var->next) {
59253 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
59254 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
59255 }
59256 PyString_ConcatAndDel(&str,PyString_FromString(")"));
59257 return str;
59258 }
59259
59260 SWIGINTERN int
59261 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
59262 PyObject *str = swig_varlink_str(v);
59263 fprintf(fp,"Swig global variables ");
59264 fprintf(fp,"%s\n", PyString_AsString(str));
59265 Py_DECREF(str);
59266 return 0;
59267 }
59268
59269 SWIGINTERN void
59270 swig_varlink_dealloc(swig_varlinkobject *v) {
59271 swig_globalvar *var = v->vars;
59272 while (var) {
59273 swig_globalvar *n = var->next;
59274 free(var->name);
59275 free(var);
59276 var = n;
59277 }
59278 }
59279
59280 SWIGINTERN PyObject *
59281 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
59282 PyObject *res = NULL;
59283 swig_globalvar *var = v->vars;
59284 while (var) {
59285 if (strcmp(var->name,n) == 0) {
59286 res = (*var->get_attr)();
59287 break;
59288 }
59289 var = var->next;
59290 }
59291 if (res == NULL && !PyErr_Occurred()) {
59292 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59293 }
59294 return res;
59295 }
59296
59297 SWIGINTERN int
59298 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
59299 int res = 1;
59300 swig_globalvar *var = v->vars;
59301 while (var) {
59302 if (strcmp(var->name,n) == 0) {
59303 res = (*var->set_attr)(p);
59304 break;
59305 }
59306 var = var->next;
59307 }
59308 if (res == 1 && !PyErr_Occurred()) {
59309 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59310 }
59311 return res;
59312 }
59313
59314 SWIGINTERN PyTypeObject*
59315 swig_varlink_type(void) {
59316 static char varlink__doc__[] = "Swig var link object";
59317 static PyTypeObject varlink_type;
59318 static int type_init = 0;
59319 if (!type_init) {
59320 const PyTypeObject tmp
59321 = {
59322 PyObject_HEAD_INIT(NULL)
59323 0, /* Number of items in variable part (ob_size) */
59324 (char *)"swigvarlink", /* Type name (tp_name) */
59325 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
59326 0, /* Itemsize (tp_itemsize) */
59327 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
59328 (printfunc) swig_varlink_print, /* Print (tp_print) */
59329 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
59330 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
59331 0, /* tp_compare */
59332 (reprfunc) swig_varlink_repr, /* tp_repr */
59333 0, /* tp_as_number */
59334 0, /* tp_as_sequence */
59335 0, /* tp_as_mapping */
59336 0, /* tp_hash */
59337 0, /* tp_call */
59338 (reprfunc)swig_varlink_str, /* tp_str */
59339 0, /* tp_getattro */
59340 0, /* tp_setattro */
59341 0, /* tp_as_buffer */
59342 0, /* tp_flags */
59343 varlink__doc__, /* tp_doc */
59344 0, /* tp_traverse */
59345 0, /* tp_clear */
59346 0, /* tp_richcompare */
59347 0, /* tp_weaklistoffset */
59348 #if PY_VERSION_HEX >= 0x02020000
59349 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
59350 #endif
59351 #if PY_VERSION_HEX >= 0x02030000
59352 0, /* tp_del */
59353 #endif
59354 #ifdef COUNT_ALLOCS
59355 0,0,0,0 /* tp_alloc -> tp_next */
59356 #endif
59357 };
59358 varlink_type = tmp;
59359 varlink_type.ob_type = &PyType_Type;
59360 type_init = 1;
59361 }
59362 return &varlink_type;
59363 }
59364
59365 /* Create a variable linking object for use later */
59366 SWIGINTERN PyObject *
59367 SWIG_Python_newvarlink(void) {
59368 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
59369 if (result) {
59370 result->vars = 0;
59371 }
59372 return ((PyObject*) result);
59373 }
59374
59375 SWIGINTERN void
59376 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
59377 swig_varlinkobject *v = (swig_varlinkobject *) p;
59378 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
59379 if (gv) {
59380 size_t size = strlen(name)+1;
59381 gv->name = (char *)malloc(size);
59382 if (gv->name) {
59383 strncpy(gv->name,name,size);
59384 gv->get_attr = get_attr;
59385 gv->set_attr = set_attr;
59386 gv->next = v->vars;
59387 }
59388 }
59389 v->vars = gv;
59390 }
59391
59392 SWIGINTERN PyObject *
59393 SWIG_globals() {
59394 static PyObject *_SWIG_globals = 0;
59395 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
59396 return _SWIG_globals;
59397 }
59398
59399 /* -----------------------------------------------------------------------------
59400 * constants/methods manipulation
59401 * ----------------------------------------------------------------------------- */
59402
59403 /* Install Constants */
59404 SWIGINTERN void
59405 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
59406 PyObject *obj = 0;
59407 size_t i;
59408 for (i = 0; constants[i].type; ++i) {
59409 switch(constants[i].type) {
59410 case SWIG_PY_POINTER:
59411 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
59412 break;
59413 case SWIG_PY_BINARY:
59414 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
59415 break;
59416 default:
59417 obj = 0;
59418 break;
59419 }
59420 if (obj) {
59421 PyDict_SetItemString(d, constants[i].name, obj);
59422 Py_DECREF(obj);
59423 }
59424 }
59425 }
59426
59427 /* -----------------------------------------------------------------------------*/
59428 /* Fix SwigMethods to carry the callback ptrs when needed */
59429 /* -----------------------------------------------------------------------------*/
59430
59431 SWIGINTERN void
59432 SWIG_Python_FixMethods(PyMethodDef *methods,
59433 swig_const_info *const_table,
59434 swig_type_info **types,
59435 swig_type_info **types_initial) {
59436 size_t i;
59437 for (i = 0; methods[i].ml_name; ++i) {
59438 const char *c = methods[i].ml_doc;
59439 if (c && (c = strstr(c, "swig_ptr: "))) {
59440 int j;
59441 swig_const_info *ci = 0;
59442 const char *name = c + 10;
59443 for (j = 0; const_table[j].type; ++j) {
59444 if (strncmp(const_table[j].name, name,
59445 strlen(const_table[j].name)) == 0) {
59446 ci = &(const_table[j]);
59447 break;
59448 }
59449 }
59450 if (ci) {
59451 size_t shift = (ci->ptype) - types;
59452 swig_type_info *ty = types_initial[shift];
59453 size_t ldoc = (c - methods[i].ml_doc);
59454 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
59455 char *ndoc = (char*)malloc(ldoc + lptr + 10);
59456 if (ndoc) {
59457 char *buff = ndoc;
59458 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
59459 if (ptr) {
59460 strncpy(buff, methods[i].ml_doc, ldoc);
59461 buff += ldoc;
59462 strncpy(buff, "swig_ptr: ", 10);
59463 buff += 10;
59464 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
59465 methods[i].ml_doc = ndoc;
59466 }
59467 }
59468 }
59469 }
59470 }
59471 }
59472
59473 #ifdef __cplusplus
59474 }
59475 #endif
59476
59477 /* -----------------------------------------------------------------------------*
59478 * Partial Init method
59479 * -----------------------------------------------------------------------------*/
59480
59481 #ifdef __cplusplus
59482 extern "C"
59483 #endif
59484 SWIGEXPORT void SWIG_init(void) {
59485 PyObject *m, *d;
59486
59487 /* Fix SwigMethods to carry the callback ptrs when needed */
59488 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
59489
59490 m = Py_InitModule((char *) SWIG_name, SwigMethods);
59491 d = PyModule_GetDict(m);
59492
59493 SWIG_InitializeModule(0);
59494 SWIG_InstallConstants(d,swig_const_table);
59495
59496
59497
59498 #ifndef wxPyUSE_EXPORT
59499 // Make our API structure a CObject so other modules can import it
59500 // from this module.
59501 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
59502 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
59503 Py_XDECREF(cobj);
59504 #endif
59505
59506 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
59507 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
59508 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
59509 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
59510 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
59511 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
59512 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
59513 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
59514 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
59515 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
59516 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
59517 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
59518 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
59519 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
59520 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
59521 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
59522 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
59523 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
59524 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
59525 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
59526 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
59527 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
59528 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
59529 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
59530 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
59531 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
59532 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
59533 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
59534 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
59535 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
59536 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
59537 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
59538 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
59539 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
59540 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
59541 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
59542 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
59543 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
59544 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
59545 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
59546 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
59547 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
59548 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
59549 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
59550 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
59551 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
59552 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
59553 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
59554 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
59555 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
59556 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
59557 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
59558 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
59559 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
59560 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
59561 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
59562 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
59563 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
59564 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
59565 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
59566 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
59567 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
59568 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
59569 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
59570 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
59571 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
59572 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
59573 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
59574 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
59575 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
59576 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
59577 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
59578 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
59579 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
59580 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
59581 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
59582 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
59583 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
59584 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
59585 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
59586 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
59587 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
59588 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
59589 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
59590 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
59591 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
59592 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
59593 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
59594 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
59595 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
59596 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
59597 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
59598 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
59599 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
59600 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
59601 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
59602 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
59603 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
59604 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
59605 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
59606 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
59607 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
59608 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
59609 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
59610 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
59611 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
59612 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
59613 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
59614 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
59615 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
59616 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
59617 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
59618 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
59619 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
59620 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
59621 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
59622 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
59623 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
59624 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
59625 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
59626 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
59627 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
59628 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
59629 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
59630 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
59631 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
59632 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
59633 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
59634 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
59635 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
59636 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
59637 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
59638 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
59639 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
59640 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
59641 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
59642 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
59643 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
59644 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
59645 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
59646 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
59647 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
59648 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
59649 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
59650 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
59651 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
59652 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
59653 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
59654 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
59655 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
59656 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
59657 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
59658 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
59659 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
59660 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
59661 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
59662 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
59663 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
59664 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
59665 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
59666 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
59667 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
59668 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
59669 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
59670 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
59671 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
59672 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
59673 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
59674 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
59675 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
59676 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
59677 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
59678 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
59679 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
59680 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
59681 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
59682 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
59683 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
59684 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
59685 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
59686 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
59687 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
59688 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
59689 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
59690 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
59691 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
59692 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
59693 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
59694 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
59695 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
59696 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
59697 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
59698 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
59699 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
59700 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
59701 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
59702 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
59703 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
59704 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
59705 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
59706 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
59707 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
59708 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
59709 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
59710 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
59711 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
59712 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
59713 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
59714 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
59715 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
59716 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
59717 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
59718 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
59719 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
59720 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
59721 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
59722 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
59723 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
59724 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
59725 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
59726 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
59727 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
59728 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
59729 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
59730 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
59731 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
59732 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
59733 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
59734 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
59735 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
59736 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
59737 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
59738 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
59739 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
59740 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
59741 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
59742 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
59743 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
59744 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
59745 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
59746 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
59747 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
59748 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
59749 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
59750 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
59751 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
59752 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
59753 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
59754 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
59755 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
59756 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
59757 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
59758 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
59759 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
59760 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
59761 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
59762 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
59763 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
59764 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
59765 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
59766 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
59767 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
59768 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
59769 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
59770 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
59771 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
59772 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
59773 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
59774 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
59775 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
59776 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
59777 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
59778 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
59779 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
59780 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
59781 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
59782 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
59783 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
59784 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
59785 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
59786 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
59787 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
59788 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
59789 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
59790 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
59791 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
59792 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
59793 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
59794 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
59795 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
59796 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
59797 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
59798 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
59799 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
59800 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
59801 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
59802 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
59803 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
59804 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
59805 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
59806 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
59807 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
59808 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
59809 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
59810 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
59811 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
59812 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
59813 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
59814 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
59815 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
59816 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
59817 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
59818 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
59819 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
59820 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
59821 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
59822 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
59823 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
59824 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
59825 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
59826 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
59827 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
59828 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
59829 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
59830 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
59831 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
59832 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
59833 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
59834 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
59835 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
59836 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
59837 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
59838 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
59839 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
59840 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
59841 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
59842 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
59843 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
59844 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
59845 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
59846 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
59847 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
59848 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
59849 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
59850 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
59851 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
59852 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
59853 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
59854 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
59855 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
59856 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
59857 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
59858 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
59859 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
59860 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
59861 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
59862 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
59863 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
59864 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
59865 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
59866 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
59867 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
59868 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
59869 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
59870 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
59871 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
59872 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
59873 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
59874 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
59875 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
59876 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
59877 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
59878 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
59879 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
59880 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
59881 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
59882 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
59883 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
59884 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
59885 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
59886 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
59887 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
59888 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
59889 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
59890 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
59891 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
59892 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
59893 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
59894 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
59895 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
59896 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
59897 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
59898 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
59899 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
59900 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
59901 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
59902 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
59903 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
59904 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
59905 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
59906 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
59907 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
59908 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
59909 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
59910 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
59911 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
59912 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
59913 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
59914 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
59915 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
59916 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
59917 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
59918 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
59919 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
59920 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
59921 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
59922 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
59923 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
59924 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
59925 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
59926 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
59927 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
59928 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
59929 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
59930 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
59931 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
59932 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
59933 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
59934 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
59935 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
59936 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
59937 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
59938 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
59939 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
59940 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
59941 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
59942 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
59943 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
59944 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
59945 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
59946 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
59947 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
59948 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
59949 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
59950 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
59951 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
59952 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
59953 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
59954 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
59955 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
59956 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
59957 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
59958 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
59959 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
59960 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
59961 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
59962 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
59963 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
59964 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
59965 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
59966 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
59967 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
59968 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
59969 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
59970 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
59971 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
59972 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
59973 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
59974 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
59975 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
59976 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
59977 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
59978 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
59979 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
59980 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
59981 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
59982 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
59983 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
59984 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
59985 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
59986 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
59987 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
59988 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
59989 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
59990 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
59991 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
59992 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
59993 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
59994 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
59995 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
59996 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
59997 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
59998 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
59999 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
60000 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
60001 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
60002 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
60003 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
60004 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
60005 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
60006 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
60007 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
60008 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
60009 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
60010 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
60011 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
60012 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
60013 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
60014 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
60015 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
60016 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
60017 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
60018 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
60019 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
60020 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
60021 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
60022 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
60023 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
60024 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
60025 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
60026 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
60027 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
60028 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
60029 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
60030 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
60031 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
60032 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
60033 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
60034 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
60035 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
60036 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
60037 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
60038 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
60039 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
60040 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
60041 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
60042 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
60043 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
60044 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
60045 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
60046 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
60047 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
60048 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
60049 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
60050 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
60051 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
60052 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
60053 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
60054 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
60055 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
60056 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
60057 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
60058 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
60059 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
60060 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
60061 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
60062 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
60063 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
60064 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
60065 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
60066 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
60067 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
60068 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
60069 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
60070 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
60071 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
60072 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
60073 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
60074 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
60075 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
60076 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
60077 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
60078 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
60079 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
60080 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
60081 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
60082 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
60083 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
60084 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
60085 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
60086 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
60087 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
60088 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
60089 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
60090 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
60091 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
60092 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
60093 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
60094 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
60095 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
60096 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
60097 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
60098 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
60099 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
60100 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
60101 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
60102 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
60103 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
60104 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
60105 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
60106 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
60107 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
60108 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
60109 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
60110 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
60111 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
60112 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
60113 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
60114 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
60115 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
60116 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
60117 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
60118 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
60119 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
60120 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
60121 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
60122 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
60123 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
60124 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
60125 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
60126 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
60127 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
60128 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
60129 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
60130 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
60131 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
60132 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
60133 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
60134 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
60135 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
60136 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
60137 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
60138 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
60139 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
60140 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
60141 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
60142 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
60143 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
60144 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
60145 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
60146 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
60147 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
60148 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
60149 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
60150 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
60151 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
60152 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
60153 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
60154 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
60155 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
60156 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
60157 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
60158 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
60159 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
60160 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
60161 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
60162 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
60163 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
60164 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
60165 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
60166 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
60167 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
60168 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
60169 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
60170 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
60171
60172 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
60173
60174
60175 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
60176
60177 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
60178 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
60179 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
60180 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
60181 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
60182 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
60183 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
60184 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
60185 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
60186 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
60187 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
60188 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
60189 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
60190 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
60191 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
60192 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
60193 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
60194 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
60195 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
60196 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
60197 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
60198 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
60199 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
60200 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
60201 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
60202 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
60203 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
60204 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
60205 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
60206 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
60207 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
60208 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
60209 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
60210 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
60211 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
60212 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
60213 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
60214 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
60215 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
60216 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
60217 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
60218 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
60219 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
60220 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
60221 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
60222 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
60223 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
60224 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
60225 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
60226 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
60227 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
60228 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
60229 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
60230 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
60231 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
60232 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
60233 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
60234 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
60235 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
60236 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
60237 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
60238 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
60239 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
60240 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
60241 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
60242 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
60243 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
60244 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
60245 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
60246 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
60247 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
60248 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
60249 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
60250 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
60251 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
60252 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
60253 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
60254 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
60255 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
60256 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
60257 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
60258 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
60259 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
60260 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
60261 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
60262 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
60263 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
60264 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
60265 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
60266 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
60267 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
60268 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
60269 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
60270 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
60271 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
60272 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
60273 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
60274 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
60275 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
60276 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
60277 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
60278 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
60279 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
60280 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
60281 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
60282 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
60283 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
60284 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
60285 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
60286 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
60287 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
60288 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
60289 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
60290 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
60291 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
60292 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
60293 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
60294 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
60295 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
60296 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
60297 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
60298 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
60299 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
60300 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
60301 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
60302 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
60303 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
60304 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
60305 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
60306 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
60307 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
60308 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
60309 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
60310 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
60311 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
60312 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
60313 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
60314 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
60315 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
60316 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
60317 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
60318 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
60319 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
60320 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
60321 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
60322 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
60323 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
60324 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
60325 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
60326 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
60327 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
60328 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
60329 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
60330 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
60331 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
60332 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
60333 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
60334 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
60335 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
60336 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
60337 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
60338 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
60339 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
60340 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
60341 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
60342 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
60343 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
60344 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
60345 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
60346 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
60347 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
60348 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
60349 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
60350 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
60351 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
60352 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
60353 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
60354 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
60355 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
60356 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
60357 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
60358 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
60359 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
60360 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
60361 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
60362 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
60363 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
60364 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
60365 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
60366 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
60367 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
60368 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
60369 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
60370 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
60371 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
60372 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
60373 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
60374 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
60375 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
60376 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
60377 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
60378 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
60379 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
60380 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
60381 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
60382 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
60383 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
60384 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
60385 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
60386 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
60387 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
60388 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
60389 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
60390 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
60391
60392 // Initialize threading, some globals and such
60393 __wxPyPreStart(d);
60394
60395
60396 // Although these are defined in __version__ they need to be here too so
60397 // that an assert can be done to ensure that the wxPython and the wxWindows
60398 // versions match.
60399 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
60400 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
60401 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
60402
60403 }
60404
wxWidgets (Impactor)