]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Elippsis and markup support for wxStaticText
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_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_wxEventBlocker swig_types[38]
2505 #define SWIGTYPE_p_wxEventLoop swig_types[39]
2506 #define SWIGTYPE_p_wxEventLoopActivator swig_types[40]
2507 #define SWIGTYPE_p_wxEvtHandler swig_types[41]
2508 #define SWIGTYPE_p_wxFSFile swig_types[42]
2509 #define SWIGTYPE_p_wxFileSystem swig_types[43]
2510 #define SWIGTYPE_p_wxFileSystemHandler swig_types[44]
2511 #define SWIGTYPE_p_wxFlexGridSizer swig_types[45]
2512 #define SWIGTYPE_p_wxFocusEvent swig_types[46]
2513 #define SWIGTYPE_p_wxFont swig_types[47]
2514 #define SWIGTYPE_p_wxFrame swig_types[48]
2515 #define SWIGTYPE_p_wxGBPosition swig_types[49]
2516 #define SWIGTYPE_p_wxGBSizerItem swig_types[50]
2517 #define SWIGTYPE_p_wxGBSpan swig_types[51]
2518 #define SWIGTYPE_p_wxGIFHandler swig_types[52]
2519 #define SWIGTYPE_p_wxGridBagSizer swig_types[53]
2520 #define SWIGTYPE_p_wxGridSizer swig_types[54]
2521 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[55]
2522 #define SWIGTYPE_p_wxICOHandler swig_types[56]
2523 #define SWIGTYPE_p_wxIconizeEvent swig_types[57]
2524 #define SWIGTYPE_p_wxIdleEvent swig_types[58]
2525 #define SWIGTYPE_p_wxImage swig_types[59]
2526 #define SWIGTYPE_p_wxImageHandler swig_types[60]
2527 #define SWIGTYPE_p_wxImageHistogram swig_types[61]
2528 #define SWIGTYPE_p_wxImage_HSVValue swig_types[62]
2529 #define SWIGTYPE_p_wxImage_RGBValue swig_types[63]
2530 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[64]
2531 #define SWIGTYPE_p_wxInitDialogEvent swig_types[65]
2532 #define SWIGTYPE_p_wxInputStream swig_types[66]
2533 #define SWIGTYPE_p_wxInternetFSHandler swig_types[67]
2534 #define SWIGTYPE_p_wxItemContainer swig_types[68]
2535 #define SWIGTYPE_p_wxJPEGHandler swig_types[69]
2536 #define SWIGTYPE_p_wxKeyEvent swig_types[70]
2537 #define SWIGTYPE_p_wxLayoutConstraints swig_types[71]
2538 #define SWIGTYPE_p_wxMaximizeEvent swig_types[72]
2539 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[73]
2540 #define SWIGTYPE_p_wxMenu swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBar swig_types[75]
2542 #define SWIGTYPE_p_wxMenuBarBase swig_types[76]
2543 #define SWIGTYPE_p_wxMenuEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMenuItem swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMouseEvent swig_types[81]
2548 #define SWIGTYPE_p_wxMoveEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNcPaintEvent swig_types[84]
2551 #define SWIGTYPE_p_wxNotifyEvent swig_types[85]
2552 #define SWIGTYPE_p_wxObject swig_types[86]
2553 #define SWIGTYPE_p_wxOutputStream swig_types[87]
2554 #define SWIGTYPE_p_wxPCXHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNGHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPNMHandler swig_types[90]
2557 #define SWIGTYPE_p_wxPaintEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[92]
2559 #define SWIGTYPE_p_wxPaperSize swig_types[93]
2560 #define SWIGTYPE_p_wxPoint swig_types[94]
2561 #define SWIGTYPE_p_wxPoint2D swig_types[95]
2562 #define SWIGTYPE_p_wxPropagateOnce swig_types[96]
2563 #define SWIGTYPE_p_wxPropagationDisabler swig_types[97]
2564 #define SWIGTYPE_p_wxPyApp swig_types[98]
2565 #define SWIGTYPE_p_wxPyCommandEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyDropTarget swig_types[100]
2567 #define SWIGTYPE_p_wxPyEvent swig_types[101]
2568 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[102]
2569 #define SWIGTYPE_p_wxPyImageHandler swig_types[103]
2570 #define SWIGTYPE_p_wxPyInputStream swig_types[104]
2571 #define SWIGTYPE_p_wxPySizer swig_types[105]
2572 #define SWIGTYPE_p_wxPyValidator swig_types[106]
2573 #define SWIGTYPE_p_wxQuantize swig_types[107]
2574 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[108]
2575 #define SWIGTYPE_p_wxRealPoint swig_types[109]
2576 #define SWIGTYPE_p_wxRect swig_types[110]
2577 #define SWIGTYPE_p_wxRect2D swig_types[111]
2578 #define SWIGTYPE_p_wxRegion swig_types[112]
2579 #define SWIGTYPE_p_wxScrollEvent swig_types[113]
2580 #define SWIGTYPE_p_wxScrollWinEvent swig_types[114]
2581 #define SWIGTYPE_p_wxSetCursorEvent swig_types[115]
2582 #define SWIGTYPE_p_wxShowEvent swig_types[116]
2583 #define SWIGTYPE_p_wxSize swig_types[117]
2584 #define SWIGTYPE_p_wxSizeEvent swig_types[118]
2585 #define SWIGTYPE_p_wxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxSizerFlags swig_types[120]
2587 #define SWIGTYPE_p_wxSizerItem swig_types[121]
2588 #define SWIGTYPE_p_wxStaticBox swig_types[122]
2589 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[123]
2590 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[124]
2591 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[125]
2592 #define SWIGTYPE_p_wxTGAHandler swig_types[126]
2593 #define SWIGTYPE_p_wxTIFFHandler swig_types[127]
2594 #define SWIGTYPE_p_wxToolTip swig_types[128]
2595 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[129]
2596 #define SWIGTYPE_p_wxValidator swig_types[130]
2597 #define SWIGTYPE_p_wxVisualAttributes swig_types[131]
2598 #define SWIGTYPE_p_wxWindow swig_types[132]
2599 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[133]
2600 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[134]
2601 #define SWIGTYPE_p_wxXPMHandler swig_types[135]
2602 #define SWIGTYPE_p_wxZipFSHandler swig_types[136]
2603 static swig_type_info *swig_types[138];
2604 static swig_module_info swig_module = {swig_types, 137, 0, 0, 0, 0};
2605 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2606 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2607
2608 /* -------- TYPES TABLE (END) -------- */
2609
2610 #if (PY_VERSION_HEX <= 0x02000000)
2611 # if !defined(SWIG_PYTHON_CLASSIC)
2612 # error "This python version requires to use swig with the '-classic' option"
2613 # endif
2614 #endif
2615 #if (PY_VERSION_HEX <= 0x02020000)
2616 # error "This python version requires to use swig with the '-nomodern' option"
2617 #endif
2618 #if (PY_VERSION_HEX <= 0x02020000)
2619 # error "This python version requires to use swig with the '-nomodernargs' option"
2620 #endif
2621 #ifndef METH_O
2622 # error "This python version requires to use swig with the '-nofastunpack' option"
2623 #endif
2624
2625 /*-----------------------------------------------
2626 @(target):= _core_.so
2627 ------------------------------------------------*/
2628 #define SWIG_init init_core_
2629
2630 #define SWIG_name "_core_"
2631
2632 #define SWIGVERSION 0x010329
2633
2634
2635 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2636 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2637
2638
2639 #include <stdexcept>
2640
2641
2642 namespace swig {
2643 class PyObject_ptr {
2644 protected:
2645 PyObject *_obj;
2646
2647 public:
2648 PyObject_ptr() :_obj(0)
2649 {
2650 }
2651
2652 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2653 {
2654 Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2658 {
2659 if (initial_ref) Py_XINCREF(_obj);
2660 }
2661
2662 PyObject_ptr & operator=(const PyObject_ptr& item)
2663 {
2664 Py_XINCREF(item._obj);
2665 Py_XDECREF(_obj);
2666 _obj = item._obj;
2667 return *this;
2668 }
2669
2670 ~PyObject_ptr()
2671 {
2672 Py_XDECREF(_obj);
2673 }
2674
2675 operator PyObject *() const
2676 {
2677 return _obj;
2678 }
2679
2680 PyObject *operator->() const
2681 {
2682 return _obj;
2683 }
2684 };
2685 }
2686
2687
2688 namespace swig {
2689 struct PyObject_var : PyObject_ptr {
2690 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2691
2692 PyObject_var & operator = (PyObject* obj)
2693 {
2694 Py_XDECREF(_obj);
2695 _obj = obj;
2696 return *this;
2697 }
2698 };
2699 }
2700
2701
2702 #include "wx/wxPython/wxPython_int.h"
2703 #include "wx/wxPython/pyclasses.h"
2704 #include "wx/wxPython/twoitem.h"
2705
2706
2707 #ifndef wxPyUSE_EXPORT
2708 // Helper functions for dealing with SWIG objects and such. These are
2709 // located here so they know about the SWIG types and functions declared
2710 // in the wrapper code.
2711
2712 #include <wx/hashmap.h>
2713 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2714
2715
2716 // Maintains a hashmap of className to swig_type_info pointers. Given the
2717 // name of a class either looks up the type info in the cache, or scans the
2718 // SWIG tables for it.
2719 extern PyObject* wxPyPtrTypeMap;
2720 static
2721 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2722
2723 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2724
2725 if (typeInfoCache == NULL)
2726 typeInfoCache = new wxPyTypeInfoHashMap;
2727
2728 wxString name(className);
2729 swig_type_info* swigType = (*typeInfoCache)[name];
2730
2731 if (! swigType) {
2732 // it wasn't in the cache, so look it up from SWIG
2733 name.Append(wxT(" *"));
2734 swigType = SWIG_TypeQuery(name.mb_str());
2735
2736 // if it still wasn't found, try looking for a mapped name
2737 if (!swigType) {
2738 PyObject* item;
2739 name = className;
2740
2741 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2742 (char*)(const char*)name.mbc_str())) != NULL) {
2743 name = wxString(PyString_AsString(item), *wxConvCurrent);
2744 name.Append(wxT(" *"));
2745 swigType = SWIG_TypeQuery(name.mb_str());
2746 }
2747 }
2748 if (swigType) {
2749 // and add it to the map if found
2750 (*typeInfoCache)[className] = swigType;
2751 }
2752 }
2753 return swigType;
2754 }
2755
2756
2757 // Check if a class name is a type known to SWIG
2758 bool wxPyCheckSwigType(const wxChar* className) {
2759
2760 swig_type_info* swigType = wxPyFindSwigType(className);
2761 return swigType != NULL;
2762 }
2763
2764
2765 // Given a pointer to a C++ object and a class name, construct a Python proxy
2766 // object for it.
2767 PyObject* wxPyConstructObject(void* ptr,
2768 const wxChar* className,
2769 int setThisOwn) {
2770
2771 swig_type_info* swigType = wxPyFindSwigType(className);
2772 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2773
2774 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2775 }
2776
2777
2778 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2779 // Ensures that the proxy object is of the specified (or derived) type. If
2780 // not able to perform the conversion then a Python exception is set and the
2781 // error should be handled properly in the caller. Returns True on success.
2782 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2783 const wxChar* className) {
2784
2785 swig_type_info* swigType = wxPyFindSwigType(className);
2786 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2787
2788 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2789 }
2790
2791
2792
2793 // Make a SWIGified pointer object suitable for a .this attribute
2794 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2795
2796 PyObject* robj = NULL;
2797
2798 swig_type_info* swigType = wxPyFindSwigType(className);
2799 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2800
2801 robj = PySwigObject_New(ptr, swigType, 0);
2802 return robj;
2803 }
2804
2805
2806 // Python's PyInstance_Check does not return True for instances of new-style
2807 // classes. This should get close enough for both new and old classes but I
2808 // should re-evaluate the need for doing instance checks...
2809 bool wxPyInstance_Check(PyObject* obj) {
2810 return PyObject_HasAttrString(obj, "__class__") != 0;
2811 }
2812
2813
2814 // This one checks if the object is an instance of a SWIG proxy class (it has
2815 // a .this attribute, and the .this attribute is a PySwigObject.)
2816 bool wxPySwigInstance_Check(PyObject* obj) {
2817 static PyObject* this_str = NULL;
2818 if (this_str == NULL)
2819 this_str = PyString_FromString("this");
2820
2821 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2822 if (this_attr) {
2823 bool retval = (PySwigObject_Check(this_attr) != 0);
2824 Py_DECREF(this_attr);
2825 return retval;
2826 }
2827
2828 PyErr_Clear();
2829 return false;
2830 }
2831
2832
2833 // Export a C API in a struct. Other modules will be able to load this from
2834 // the wx._core_ module and will then have safe access to these functions,
2835 // even if they are located in another shared library.
2836 static wxPyCoreAPI API = {
2837
2838 wxPyCheckSwigType,
2839 wxPyConstructObject,
2840 wxPyConvertSwigPtr,
2841 wxPyMakeSwigPtr,
2842
2843 wxPyBeginAllowThreads,
2844 wxPyEndAllowThreads,
2845 wxPyBeginBlockThreads,
2846 wxPyEndBlockThreads,
2847
2848 wxPy_ConvertList,
2849
2850 wxString_in_helper,
2851 Py2wxString,
2852 wx2PyString,
2853
2854 byte_LIST_helper,
2855 int_LIST_helper,
2856 long_LIST_helper,
2857 string_LIST_helper,
2858 wxPoint_LIST_helper,
2859 wxBitmap_LIST_helper,
2860 wxString_LIST_helper,
2861 wxAcceleratorEntry_LIST_helper,
2862
2863 wxSize_helper,
2864 wxPoint_helper,
2865 wxRealPoint_helper,
2866 wxRect_helper,
2867 wxColour_helper,
2868 wxPoint2D_helper,
2869
2870 wxPySimple_typecheck,
2871 wxColour_typecheck,
2872
2873 wxPyCBH_setCallbackInfo,
2874 wxPyCBH_findCallback,
2875 wxPyCBH_callCallback,
2876 wxPyCBH_callCallbackObj,
2877 wxPyCBH_delete,
2878
2879 wxPyMake_wxObject,
2880 wxPyMake_wxSizer,
2881 wxPyPtrTypeMap_Add,
2882 wxPy2int_seq_helper,
2883 wxPy4int_seq_helper,
2884 wxArrayString2PyList_helper,
2885 wxArrayInt2PyList_helper,
2886
2887 wxPyClientData_dtor,
2888 wxPyUserData_dtor,
2889 wxPyOORClientData_dtor,
2890
2891 wxPyCBInputStream_create,
2892 wxPyCBInputStream_copy,
2893
2894 wxPyInstance_Check,
2895 wxPySwigInstance_Check,
2896
2897 wxPyCheckForApp,
2898
2899 wxArrayDouble2PyList_helper,
2900 wxPoint2D_LIST_helper,
2901 wxRect2D_helper,
2902
2903 };
2904
2905 #endif
2906
2907
2908 #if !WXWIN_COMPATIBILITY_2_4
2909 #define wxHIDE_READONLY 0
2910 #endif
2911
2912
2913 #define SWIG_From_long PyInt_FromLong
2914
2915
2916 SWIGINTERNINLINE PyObject *
2917 SWIG_From_int (int value)
2918 {
2919 return SWIG_From_long (value);
2920 }
2921
2922 static const wxString wxPyEmptyString(wxEmptyString);
2923 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2924 return self->GetClassInfo()->GetClassName();
2925 }
2926 SWIGINTERN void wxObject_Destroy(wxObject *self){
2927 delete self;
2928 }
2929
2930 #ifndef __WXMAC__
2931 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2932 #endif
2933
2934
2935 #include <limits.h>
2936 #ifndef LLONG_MIN
2937 # define LLONG_MIN LONG_LONG_MIN
2938 #endif
2939 #ifndef LLONG_MAX
2940 # define LLONG_MAX LONG_LONG_MAX
2941 #endif
2942 #ifndef ULLONG_MAX
2943 # define ULLONG_MAX ULONG_LONG_MAX
2944 #endif
2945
2946
2947 SWIGINTERN int
2948 SWIG_AsVal_long (PyObject* obj, long* val)
2949 {
2950 if (PyNumber_Check(obj)) {
2951 if (val) *val = PyInt_AsLong(obj);
2952 return SWIG_OK;
2953 }
2954 return SWIG_TypeError;
2955 }
2956
2957
2958 SWIGINTERN int
2959 SWIG_AsVal_int (PyObject * obj, int *val)
2960 {
2961 long v;
2962 int res = SWIG_AsVal_long (obj, &v);
2963 if (SWIG_IsOK(res)) {
2964 if ((v < INT_MIN || v > INT_MAX)) {
2965 return SWIG_OverflowError;
2966 } else {
2967 if (val) *val = static_cast< int >(v);
2968 }
2969 }
2970 return res;
2971 }
2972
2973 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return false;
2976 if ( ! wxSize_helper(other, &obj) ) {
2977 PyErr_Clear();
2978 return false;
2979 }
2980 return self->operator==(*obj);
2981 }
2982 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2983 wxSize temp, *obj = &temp;
2984 if ( other == Py_None ) return true;
2985 if ( ! wxSize_helper(other, &obj)) {
2986 PyErr_Clear();
2987 return true;
2988 }
2989 return self->operator!=(*obj);
2990 }
2991
2992 #include <float.h>
2993
2994
2995 SWIGINTERN int
2996 SWIG_AsVal_double (PyObject *obj, double* val)
2997 {
2998 if (PyNumber_Check(obj)) {
2999 if (val) *val = PyFloat_AsDouble(obj);
3000 return SWIG_OK;
3001 }
3002 return SWIG_TypeError;
3003 }
3004
3005
3006 SWIGINTERN int
3007 SWIG_AsVal_float (PyObject * obj, float *val)
3008 {
3009 double v;
3010 int res = SWIG_AsVal_double (obj, &v);
3011 if (SWIG_IsOK(res)) {
3012 if ((v < -FLT_MAX || v > FLT_MAX)) {
3013 return SWIG_OverflowError;
3014 } else {
3015 if (val) *val = static_cast< float >(v);
3016 }
3017 }
3018 return res;
3019 }
3020
3021 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3022 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3023 PyObject* tup = PyTuple_New(2);
3024 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3025 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3026 //wxPyEndBlockThreads(blocked);
3027 return tup;
3028 }
3029
3030 #define SWIG_From_double PyFloat_FromDouble
3031
3032 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return false;
3035 if ( ! wxRealPoint_helper(other, &obj) ) {
3036 PyErr_Clear();
3037 return false;
3038 }
3039 return self->operator==(*obj);
3040 }
3041 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3042 wxRealPoint temp, *obj = &temp;
3043 if ( other == Py_None ) return true;
3044 if ( ! wxRealPoint_helper(other, &obj)) {
3045 PyErr_Clear();
3046 return true;
3047 }
3048 return self->operator!=(*obj);
3049 }
3050 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3051 self->x = x;
3052 self->y = y;
3053 }
3054 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3055 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3056 PyObject* tup = PyTuple_New(2);
3057 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3058 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3059 //PyEndBlockThreads(blocked);
3060 return tup;
3061 }
3062 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return false;
3065 if ( ! wxPoint_helper(other, &obj) ) {
3066 PyErr_Clear();
3067 return false;
3068 }
3069 return self->operator==(*obj);
3070 }
3071 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3072 wxPoint temp, *obj = &temp;
3073 if ( other == Py_None ) return true;
3074 if ( ! wxPoint_helper(other, &obj)) {
3075 PyErr_Clear();
3076 return true;
3077 }
3078 return self->operator!=(*obj);
3079 }
3080 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3081 self->x = x;
3082 self->y = y;
3083 }
3084 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3085 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3086 PyObject* tup = PyTuple_New(2);
3087 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3088 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3089 //wxPyEndBlockThreads(blocked);
3090 return tup;
3091 }
3092 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return false;
3095 if ( ! wxRect_helper(other, &obj) ) {
3096 PyErr_Clear();
3097 return false;
3098 }
3099 return self->operator==(*obj);
3100 }
3101 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3102 wxRect temp, *obj = &temp;
3103 if ( other == Py_None ) return true;
3104 if ( ! wxRect_helper(other, &obj)) {
3105 PyErr_Clear();
3106 return true;
3107 }
3108 return self->operator!=(*obj);
3109 }
3110 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3111 self->x = x;
3112 self->y = y;
3113 self->width = width;
3114 self->height = height;
3115 }
3116 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3117 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3118 PyObject* tup = PyTuple_New(4);
3119 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3120 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3121 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3122 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3123 //wxPyEndBlockThreads(blocked);
3124 return tup;
3125 }
3126
3127 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3128 wxRegion reg1(*r1);
3129 wxRegion reg2(*r2);
3130 wxRect dest(0,0,0,0);
3131 PyObject* obj;
3132
3133 reg1.Intersect(reg2);
3134 dest = reg1.GetBox();
3135
3136 if (dest != wxRect(0,0,0,0)) {
3137 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3138 wxRect* newRect = new wxRect(dest);
3139 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3140 //wxPyEndBlockThreads(blocked);
3141 return obj;
3142 }
3143 Py_INCREF(Py_None);
3144 return Py_None;
3145 }
3146
3147 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return false;
3150 if ( ! wxPoint2D_helper(other, &obj) ) {
3151 PyErr_Clear();
3152 return false;
3153 }
3154 return self->operator==(*obj);
3155 }
3156 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3157 wxPoint2D temp, *obj = &temp;
3158 if ( other == Py_None ) return true;
3159 if ( ! wxPoint2D_helper(other, &obj)) {
3160 PyErr_Clear();
3161 return true;
3162 }
3163 return self->operator!=(*obj);
3164 }
3165 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3166 self->m_x = x;
3167 self->m_y = y;
3168 }
3169 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3170 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3171 PyObject* tup = PyTuple_New(2);
3172 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3173 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3174 //wxPyEndBlockThreads(blocked);
3175 return tup;
3176 }
3177 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3178 wxRect2D temp, *obj = &temp;
3179 if ( other == Py_None ) return false;
3180 if ( ! wxRect2D_helper(other, &obj) ) {
3181 PyErr_Clear();
3182 return false;
3183 }
3184 return self->operator==(*obj);
3185 }
3186 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3187 wxRect2D temp, *obj = &temp;
3188 if ( other == Py_None ) return true;
3189 if ( ! wxRect2D_helper(other, &obj)) {
3190 PyErr_Clear();
3191 return true;
3192 }
3193 return self->operator!=(*obj);
3194 }
3195 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3196 self->m_x = x;
3197 self->m_y = y;
3198 self->m_width = width;
3199 self->m_height = height;
3200 }
3201 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3202 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3203 PyObject* tup = PyTuple_New(4);
3204 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3205 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3206 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3207 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3208 //wxPyEndBlockThreads(blocked);
3209 return tup;
3210 }
3211
3212 #include "wx/wxPython/pyistream.h"
3213
3214 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3215 wxInputStream* wxis = wxPyCBInputStream::create(p);
3216 if (wxis)
3217 return new wxPyInputStream(wxis);
3218 else
3219 return NULL;
3220 }
3221
3222 SWIGINTERN swig_type_info*
3223 SWIG_pchar_descriptor()
3224 {
3225 static int init = 0;
3226 static swig_type_info* info = 0;
3227 if (!init) {
3228 info = SWIG_TypeQuery("_p_char");
3229 init = 1;
3230 }
3231 return info;
3232 }
3233
3234
3235 SWIGINTERNINLINE PyObject *
3236 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3237 {
3238 if (carray) {
3239 if (size > INT_MAX) {
3240 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3241 return pchar_descriptor ?
3242 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3243 } else {
3244 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3245 }
3246 } else {
3247 return SWIG_Py_Void();
3248 }
3249 }
3250
3251
3252 SWIGINTERNINLINE PyObject *
3253 SWIG_From_char (char c)
3254 {
3255 return SWIG_FromCharPtrAndSize(&c,1);
3256 }
3257
3258
3259 SWIGINTERNINLINE PyObject*
3260 SWIG_From_unsigned_SS_long (unsigned long value)
3261 {
3262 return (value > LONG_MAX) ?
3263 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3264 }
3265
3266
3267 SWIGINTERNINLINE PyObject *
3268 SWIG_From_size_t (size_t value)
3269 {
3270 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3271 }
3272
3273
3274 SWIGINTERN int
3275 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3276 {
3277 if (PyString_Check(obj)) {
3278 char *cstr; Py_ssize_t len;
3279 PyString_AsStringAndSize(obj, &cstr, &len);
3280 if (cptr) {
3281 if (alloc) {
3282 /*
3283 In python the user should not be able to modify the inner
3284 string representation. To warranty that, if you define
3285 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3286 buffer is always returned.
3287
3288 The default behavior is just to return the pointer value,
3289 so, be careful.
3290 */
3291 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3292 if (*alloc != SWIG_OLDOBJ)
3293 #else
3294 if (*alloc == SWIG_NEWOBJ)
3295 #endif
3296 {
3297 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3298 *alloc = SWIG_NEWOBJ;
3299 }
3300 else {
3301 *cptr = cstr;
3302 *alloc = SWIG_OLDOBJ;
3303 }
3304 } else {
3305 *cptr = PyString_AsString(obj);
3306 }
3307 }
3308 if (psize) *psize = len + 1;
3309 return SWIG_OK;
3310 } else {
3311 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3312 if (pchar_descriptor) {
3313 void* vptr = 0;
3314 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3315 if (cptr) *cptr = (char *) vptr;
3316 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3317 if (alloc) *alloc = SWIG_OLDOBJ;
3318 return SWIG_OK;
3319 }
3320 }
3321 }
3322 return SWIG_TypeError;
3323 }
3324
3325
3326 SWIGINTERN int
3327 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3328 {
3329 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3330 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3331 if (SWIG_IsOK(res)) {
3332 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3333 if (csize <= size) {
3334 if (val) {
3335 if (csize) memcpy(val, cptr, csize*sizeof(char));
3336 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3337 }
3338 if (alloc == SWIG_NEWOBJ) {
3339 delete[] cptr;
3340 res = SWIG_DelNewMask(res);
3341 }
3342 return res;
3343 }
3344 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3345 }
3346 return SWIG_TypeError;
3347 }
3348
3349
3350 SWIGINTERN int
3351 SWIG_AsVal_char (PyObject * obj, char *val)
3352 {
3353 int res = SWIG_AsCharArray(obj, val, 1);
3354 if (!SWIG_IsOK(res)) {
3355 long v;
3356 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3357 if (SWIG_IsOK(res)) {
3358 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3359 if (val) *val = static_cast< char >(v);
3360 } else {
3361 res = SWIG_OverflowError;
3362 }
3363 }
3364 }
3365 return res;
3366 }
3367
3368 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3369 // We use only strings for the streams, not unicode
3370 PyObject* str = PyObject_Str(obj);
3371 if (! str) {
3372 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3373 return;
3374 }
3375 self->Write(PyString_AS_STRING(str),
3376 PyString_GET_SIZE(str));
3377 Py_DECREF(str);
3378 }
3379
3380 #include "wx/wxPython/pyistream.h"
3381
3382
3383 class wxPyFileSystemHandler : public wxFileSystemHandler
3384 {
3385 public:
3386 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3387
3388 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3389 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3390 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3391 DEC_PYCALLBACK_STRING__pure(FindNext);
3392
3393 wxString GetProtocol(const wxString& location) {
3394 return wxFileSystemHandler::GetProtocol(location);
3395 }
3396
3397 wxString GetLeftLocation(const wxString& location) {
3398 return wxFileSystemHandler::GetLeftLocation(location);
3399 }
3400
3401 wxString GetAnchor(const wxString& location) {
3402 return wxFileSystemHandler::GetAnchor(location);
3403 }
3404
3405 wxString GetRightLocation(const wxString& location) {
3406 return wxFileSystemHandler::GetRightLocation(location);
3407 }
3408
3409 wxString GetMimeTypeFromExt(const wxString& location) {
3410 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3411 }
3412
3413 PYPRIVATE;
3414 };
3415
3416
3417 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3418 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3419 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3420 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3421
3422
3423 SWIGINTERN int
3424 SWIG_AsVal_bool (PyObject *obj, bool *val)
3425 {
3426 if (obj == Py_True) {
3427 if (val) *val = true;
3428 return SWIG_OK;
3429 } else if (obj == Py_False) {
3430 if (val) *val = false;
3431 return SWIG_OK;
3432 } else {
3433 long v = 0;
3434 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3435 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3436 return res;
3437 }
3438 }
3439
3440 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3441 wxFileName fname = wxFileSystem::URLToFileName(url);
3442 return fname.GetFullPath();
3443 }
3444
3445 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3446 wxImage& image,
3447 long type) {
3448 wxMemoryFSHandler::AddFile(filename, image, type);
3449 }
3450
3451 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3452 const wxBitmap& bitmap,
3453 long type) {
3454 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3455 }
3456
3457 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3458 PyObject* data) {
3459 if (! PyString_Check(data)) {
3460 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3461 "Expected string object"));
3462 return;
3463 }
3464
3465 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3466 void* ptr = (void*)PyString_AsString(data);
3467 size_t size = PyString_Size(data);
3468 wxPyEndBlockThreads(blocked);
3469
3470 wxMemoryFSHandler::AddFile(filename, ptr, size);
3471 }
3472
3473
3474 #include "wx/wxPython/pyistream.h"
3475
3476
3477 SWIGINTERN int
3478 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3479 {
3480 long v = 0;
3481 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3482 return SWIG_TypeError;
3483 }
3484 else if (val)
3485 *val = (unsigned long)v;
3486 return SWIG_OK;
3487 }
3488
3489
3490 SWIGINTERN int
3491 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3492 {
3493 unsigned long v;
3494 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3495 if (SWIG_IsOK(res)) {
3496 if ((v > UCHAR_MAX)) {
3497 return SWIG_OverflowError;
3498 } else {
3499 if (val) *val = static_cast< unsigned char >(v);
3500 }
3501 }
3502 return res;
3503 }
3504
3505
3506 SWIGINTERNINLINE PyObject *
3507 SWIG_From_unsigned_SS_char (unsigned char value)
3508 {
3509 return SWIG_From_unsigned_SS_long (value);
3510 }
3511
3512 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3513 wxImageHistogramEntry e = (*self)[key];
3514 return e.value;
3515 }
3516 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3517 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3518 wxImageHistogramEntry e = (*self)[key];
3519 return e.value;
3520 }
3521 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3522 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3523 colour.Green(),
3524 colour.Blue());
3525 wxImageHistogramEntry e = (*self)[key];
3526 return e.value;
3527 }
3528
3529 // Pull the nested class out to the top level for SWIG's sake
3530 #define wxImage_RGBValue wxImage::RGBValue
3531 #define wxImage_HSVValue wxImage::HSVValue
3532
3533 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3534 if (width > 0 && height > 0)
3535 return new wxImage(width, height, clear);
3536 else
3537 return new wxImage;
3538 }
3539 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3540 return new wxImage(bitmap.ConvertToImage());
3541 }
3542 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3543 if (DATASIZE != width*height*3) {
3544 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3545 return NULL;
3546 }
3547
3548 // Copy the source data so the wxImage can clean it up later
3549 buffer copy = (buffer)malloc(DATASIZE);
3550 if (copy == NULL) {
3551 wxPyBLOCK_THREADS(PyErr_NoMemory());
3552 return NULL;
3553 }
3554 memcpy(copy, data, DATASIZE);
3555 return new wxImage(width, height, copy, false);
3556 }
3557 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3558 if (DATASIZE != width*height*3) {
3559 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3560 return NULL;
3561 }
3562 if (ALPHASIZE != width*height) {
3563 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3564 return NULL;
3565 }
3566
3567 // Copy the source data so the wxImage can clean it up later
3568 buffer dcopy = (buffer)malloc(DATASIZE);
3569 if (dcopy == NULL) {
3570 wxPyBLOCK_THREADS(PyErr_NoMemory());
3571 return NULL;
3572 }
3573 memcpy(dcopy, data, DATASIZE);
3574
3575 buffer acopy = (buffer)malloc(ALPHASIZE);
3576 if (acopy == NULL) {
3577 wxPyBLOCK_THREADS(PyErr_NoMemory());
3578 return NULL;
3579 }
3580 memcpy(acopy, alpha, ALPHASIZE);
3581
3582 return new wxImage(width, height, dcopy, acopy, false);
3583 }
3584 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3585 wxSize size(self->GetWidth(), self->GetHeight());
3586 return size;
3587 }
3588 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3589 buffer data = self->GetData();
3590 int len = self->GetWidth() * self->GetHeight() * 3;
3591 PyObject* rv;
3592 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3593 return rv;
3594 }
3595 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3596 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3597 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3598 return;
3599 }
3600 buffer copy = (buffer)malloc(DATASIZE);
3601 if (copy == NULL) {
3602 wxPyBLOCK_THREADS(PyErr_NoMemory());
3603 return;
3604 }
3605 memcpy(copy, data, DATASIZE);
3606 self->SetData(copy, false);
3607 // wxImage takes ownership of copy...
3608 }
3609 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3610 buffer data = self->GetData();
3611 int len = self->GetWidth() * self->GetHeight() * 3;
3612 PyObject* rv;
3613 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3614 return rv;
3615 }
3616 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3617 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3618 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3619 return;
3620 }
3621 self->SetData(data, true);
3622 }
3623 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3624 buffer data = self->GetAlpha();
3625 if (! data) {
3626 RETURN_NONE();
3627 } else {
3628 int len = self->GetWidth() * self->GetHeight();
3629 PyObject* rv;
3630 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3631 return rv;
3632 }
3633 }
3634 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3635 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3636 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3637 return;
3638 }
3639 buffer acopy = (buffer)malloc(ALPHASIZE);
3640 if (acopy == NULL) {
3641 wxPyBLOCK_THREADS(PyErr_NoMemory());
3642 return;
3643 }
3644 memcpy(acopy, alpha, ALPHASIZE);
3645 self->SetAlpha(acopy, false);
3646 // wxImage takes ownership of acopy...
3647 }
3648 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3649 buffer data = self->GetAlpha();
3650 int len = self->GetWidth() * self->GetHeight();
3651 PyObject* rv;
3652 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3653 return rv;
3654 }
3655 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3656 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3657 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3658 return;
3659 }
3660 self->SetAlpha(alpha, true);
3661 }
3662 SWIGINTERN PyObject *wxImage_GetHandlers(){
3663 wxList& list = wxImage::GetHandlers();
3664 return wxPy_ConvertList(&list);
3665 }
3666 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3667 wxBitmap bitmap(*self, depth);
3668 return bitmap;
3669 }
3670 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3671 wxImage mono = self->ConvertToMono( red, green, blue );
3672 wxBitmap bitmap( mono, 1 );
3673 return bitmap;
3674 }
3675
3676 wxImage* _ImageFromBuffer(int width, int height,
3677 buffer data, int DATASIZE,
3678 buffer alpha=NULL, int ALPHASIZE=0)
3679 {
3680 if (DATASIZE != width*height*3) {
3681 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3682 return NULL;
3683 }
3684 if (alpha != NULL) {
3685 if (ALPHASIZE != width*height) {
3686 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3687 return NULL;
3688 }
3689 return new wxImage(width, height, data, alpha, true);
3690 }
3691 return new wxImage(width, height, data, true);
3692 }
3693
3694 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3695 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3696 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3697 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3698 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3699 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3700 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3701 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3702 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3703 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3704 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3705 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3706 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3707 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3708 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3709
3710 #include <wx/imagtga.h>
3711
3712
3713 #include <wx/quantize.h>
3714
3715 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3716 return wxQuantize::Quantize(src, dest,
3717 //NULL, // palette
3718 desiredNoColours,
3719 NULL, // eightBitData
3720 flags);
3721 }
3722 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3723 if (PyCallable_Check(func)) {
3724 self->Connect(id, lastId, eventType,
3725 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3726 new wxPyCallback(func));
3727 }
3728 else if (func == Py_None) {
3729 self->Disconnect(id, lastId, eventType,
3730 (wxObjectEventFunction)
3731 &wxPyCallback::EventThunker);
3732 }
3733 else {
3734 wxPyBLOCK_THREADS(
3735 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3736 }
3737 }
3738 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3739 return self->Disconnect(id, lastId, eventType,
3740 (wxObjectEventFunction)
3741 &wxPyCallback::EventThunker);
3742 }
3743 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3744 if (_self && _self != Py_None) {
3745 self->SetClientObject(new wxPyOORClientData(_self, incref));
3746 }
3747 else {
3748 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3749 if (data) {
3750 self->SetClientObject(NULL); // This will delete it too
3751 }
3752 }
3753 }
3754
3755 #if ! wxUSE_HOTKEY
3756 #define wxEVT_HOTKEY -9999
3757 #endif
3758
3759 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3760 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3761 if (data) {
3762 Py_INCREF(data->m_obj);
3763 return data->m_obj;
3764 } else {
3765 Py_INCREF(Py_None);
3766 return Py_None;
3767 }
3768 }
3769 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3770 wxPyClientData* data = new wxPyClientData(clientData);
3771 self->SetClientObject(data);
3772 }
3773 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3774 #if wxUSE_UNICODE
3775 return self->GetUnicodeKey();
3776 #else
3777 return 0;
3778 #endif
3779 }
3780 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3781 #if wxUSE_UNICODE
3782 self->m_uniChar = uniChar;
3783 #endif
3784 }
3785
3786 SWIGINTERNINLINE PyObject *
3787 SWIG_From_unsigned_SS_int (unsigned int value)
3788 {
3789 return SWIG_From_unsigned_SS_long (value);
3790 }
3791
3792
3793 SWIGINTERN int
3794 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3795 {
3796 unsigned long v;
3797 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3798 if (SWIG_IsOK(res)) {
3799 if ((v > UINT_MAX)) {
3800 return SWIG_OverflowError;
3801 } else {
3802 if (val) *val = static_cast< unsigned int >(v);
3803 }
3804 }
3805 return res;
3806 }
3807
3808 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3809 self->m_size = size;
3810 }
3811 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3812 int count = self->GetNumberOfFiles();
3813 wxString* files = self->GetFiles();
3814 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3815 PyObject* list = PyList_New(count);
3816
3817 if (!list) {
3818 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3819 wxPyEndBlockThreads(blocked);
3820 return NULL;
3821 }
3822
3823 for (int i=0; i<count; i++) {
3824 PyList_SetItem(list, i, wx2PyString(files[i]));
3825 }
3826 wxPyEndBlockThreads(blocked);
3827 return list;
3828 }
3829
3830
3831 SWIGINTERN wxPyApp *new_wxPyApp(){
3832 wxPythonApp = new wxPyApp();
3833 return wxPythonApp;
3834 }
3835 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3836 return wxPyTestDisplayAvailable();
3837 }
3838
3839 void wxApp_CleanUp() {
3840 __wxPyCleanup();
3841 }
3842
3843
3844 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3845
3846
3847
3848
3849
3850 SWIGINTERNINLINE PyObject *
3851 SWIG_FromCharPtr(const char *cptr)
3852 {
3853 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3854 }
3855
3856
3857 #if 0 // #ifdef __WXMAC__
3858
3859 // A dummy class that raises an exception if used...
3860 class wxEventLoop
3861 {
3862 public:
3863 wxEventLoop() { wxPyRaiseNotImplemented(); }
3864 int Run() { return 0; }
3865 void Exit(int rc = 0) {}
3866 bool Pending() const { return false; }
3867 bool Dispatch() { return false; }
3868 bool IsRunning() const { return false; }
3869 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3870 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3871 };
3872
3873 #else
3874
3875 #include <wx/evtloop.h>
3876
3877 #endif
3878
3879
3880
3881 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3882 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3883 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3884 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3885 wxWindowList& list = self->GetChildren();
3886 return wxPy_ConvertList(&list);
3887 }
3888 SWIGINTERN wxWindow *wxWindow_GetTopLevelParent(wxWindow *self){
3889 return wxGetTopLevelParent(self);
3890 }
3891 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3892 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3893 #if wxUSE_HOTKEY
3894 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3895 #else
3896 return false;
3897 #endif
3898 }
3899 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3900
3901
3902
3903 return false;
3904
3905 }
3906 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3907 return wxPyGetWinHandle(self);
3908 }
3909 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3910 self->AssociateHandle((WXWidget)handle);
3911 }
3912
3913 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3914 return wxWindow::FindWindowById(id, parent);
3915 }
3916
3917 wxWindow* wxFindWindowByName( const wxString& name,
3918 const wxWindow *parent = NULL ) {
3919 return wxWindow::FindWindowByName(name, parent);
3920 }
3921
3922 wxWindow* wxFindWindowByLabel( const wxString& label,
3923 const wxWindow *parent = NULL ) {
3924 return wxWindow::FindWindowByLabel(label, parent);
3925 }
3926
3927
3928 #ifdef __WXMSW__
3929 #include <wx/msw/private.h> // to get wxGetWindowId
3930 #endif
3931
3932
3933 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3934 #ifdef __WXMSW__
3935 WXHWND hWnd = (WXHWND)_hWnd;
3936 long id = wxGetWindowId(hWnd);
3937 wxWindow* win = new wxWindow;
3938 if (parent)
3939 parent->AddChild(win);
3940 win->SetEventHandler(win);
3941 win->SetHWND(hWnd);
3942 win->SetId(id);
3943 win->SubclassWin(hWnd);
3944 win->AdoptAttributesFromHWND();
3945 win->SetupColours();
3946 return win;
3947 #else
3948 wxPyRaiseNotImplemented();
3949 return NULL;
3950 #endif
3951 }
3952
3953
3954 PyObject* GetTopLevelWindows() {
3955 return wxPy_ConvertList(&wxTopLevelWindows);
3956 }
3957
3958
3959 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3960 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3961 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3962
3963 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3964
3965
3966 SWIGINTERNINLINE int
3967 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3968 {
3969 unsigned long v;
3970 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3971 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3972 return res;
3973 }
3974
3975 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3976 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3977 wxMenuItemList& list = self->GetMenuItems();
3978 return wxPy_ConvertList(&list);
3979 }
3980 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3981 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3982 static const wxString wxPyControlNameStr(wxControlNameStr);
3983 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3984 if (clientData) {
3985 wxPyClientData* data = new wxPyClientData(clientData);
3986 return self->Append(item, data);
3987 } else
3988 return self->Append(item);
3989 }
3990 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
3991 if (clientData) {
3992 wxPyClientData* data = new wxPyClientData(clientData);
3993 return self->Insert(item, pos, data);
3994 } else
3995 return self->Insert(item, pos);
3996 }
3997 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
3998 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3999 if (data) {
4000 Py_INCREF(data->m_obj);
4001 return data->m_obj;
4002 } else {
4003 Py_INCREF(Py_None);
4004 return Py_None;
4005 }
4006 }
4007 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
4008 wxPyClientData* data = new wxPyClientData(clientData);
4009 self->SetClientObject(n, data);
4010 }
4011
4012
4013 SWIGINTERN wxSizerFlags &wxSizerFlags_Border(wxSizerFlags *self,int direction=wxALL,int borderInPixels=-1){
4014 if (borderInPixels == -1)
4015 return self->Border(direction);
4016 else
4017 return self->Border(direction, borderInPixels);
4018 }
4019 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4020 wxPyUserData* data = NULL;
4021 if ( userData ) {
4022 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4023 data = new wxPyUserData(userData);
4024 wxPyEndBlockThreads(blocked);
4025 }
4026 return new wxSizerItem(window, proportion, flag, border, data);
4027 }
4028 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4029 wxPyUserData* data = NULL;
4030 if ( userData ) {
4031 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4032 data = new wxPyUserData(userData);
4033 wxPyEndBlockThreads(blocked);
4034 }
4035 return new wxSizerItem(width, height, proportion, flag, border, data);
4036 }
4037 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4038 wxPyUserData* data = NULL;
4039 if ( userData ) {
4040 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4041 data = new wxPyUserData(userData);
4042 wxPyEndBlockThreads(blocked);
4043 }
4044 return new wxSizerItem(sizer, proportion, flag, border, data);
4045 }
4046
4047 SWIGINTERNINLINE PyObject *
4048 SWIG_From_float (float value)
4049 {
4050 return SWIG_From_double (value);
4051 }
4052
4053 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4054 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4055 if (data) {
4056 Py_INCREF(data->m_obj);
4057 return data->m_obj;
4058 } else {
4059 Py_INCREF(Py_None);
4060 return Py_None;
4061 }
4062 }
4063 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4064 wxPyUserData* data = NULL;
4065 if ( userData ) {
4066 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4067 data = new wxPyUserData(userData);
4068 wxPyEndBlockThreads(blocked);
4069 }
4070 self->SetUserData(data);
4071 }
4072
4073 // Figure out the type of the sizer item
4074
4075 struct wxPySizerItemInfo {
4076 wxPySizerItemInfo()
4077 : window(NULL), sizer(NULL), gotSize(false),
4078 size(wxDefaultSize), gotPos(false), pos(-1)
4079 {}
4080
4081 wxWindow* window;
4082 wxSizer* sizer;
4083 bool gotSize;
4084 wxSize size;
4085 bool gotPos;
4086 int pos;
4087 };
4088
4089 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4090
4091 wxPySizerItemInfo info;
4092 wxSize size;
4093 wxSize* sizePtr = &size;
4094
4095 // Find out what the type of the item is
4096 // try wxWindow
4097 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4098 PyErr_Clear();
4099 info.window = NULL;
4100
4101 // try wxSizer
4102 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4103 PyErr_Clear();
4104 info.sizer = NULL;
4105
4106 // try wxSize or (w,h)
4107 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4108 info.size = *sizePtr;
4109 info.gotSize = true;
4110 }
4111
4112 // or a single int
4113 if (checkIdx && PyInt_Check(item)) {
4114 info.pos = PyInt_AsLong(item);
4115 info.gotPos = true;
4116 }
4117 }
4118 }
4119
4120 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4121 // no expected type, figure out what kind of error message to generate
4122 if ( !checkSize && !checkIdx )
4123 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4124 else if ( checkSize && !checkIdx )
4125 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4126 else if ( !checkSize && checkIdx)
4127 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4128 else
4129 // can this one happen?
4130 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4131 }
4132
4133 return info;
4134 }
4135
4136 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4137 if (!self->GetClientObject())
4138 self->SetClientObject(new wxPyOORClientData(_self));
4139 }
4140 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4141
4142 wxPyUserData* data = NULL;
4143 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4144 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4145 if ( userData && (info.window || info.sizer || info.gotSize) )
4146 data = new wxPyUserData(userData);
4147 if ( info.sizer )
4148 PyObject_SetAttrString(item,"thisown",Py_False);
4149 wxPyEndBlockThreads(blocked);
4150
4151 // Now call the real Add method if a valid item type was found
4152 if ( info.window )
4153 return self->Add(info.window, proportion, flag, border, data);
4154 else if ( info.sizer )
4155 return self->Add(info.sizer, proportion, flag, border, data);
4156 else if (info.gotSize)
4157 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4158 proportion, flag, border, data);
4159 else
4160 return NULL;
4161 }
4162 SWIGINTERN wxSizerItem *wxSizer_AddF(wxSizer *self,PyObject *item,wxSizerFlags &flags){
4163
4164 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4165 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4166 if ( info.sizer )
4167 PyObject_SetAttrString(item,"thisown",Py_False);
4168 wxPyEndBlockThreads(blocked);
4169
4170 // Now call the real Add method if a valid item type was found
4171 if ( info.window )
4172 return self->Add(info.window, flags);
4173 else if ( info.sizer )
4174 return self->Add(info.sizer, flags);
4175 else if (info.gotSize)
4176 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4177 flags.GetProportion(),
4178 flags.GetFlags(),
4179 flags.GetBorderInPixels());
4180 else
4181 return NULL;
4182 }
4183 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4184
4185 wxPyUserData* data = NULL;
4186 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4187 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4188 if ( userData && (info.window || info.sizer || info.gotSize) )
4189 data = new wxPyUserData(userData);
4190 if ( info.sizer )
4191 PyObject_SetAttrString(item,"thisown",Py_False);
4192 wxPyEndBlockThreads(blocked);
4193
4194 // Now call the real Insert method if a valid item type was found
4195 if ( info.window )
4196 return self->Insert(before, info.window, proportion, flag, border, data);
4197 else if ( info.sizer )
4198 return self->Insert(before, info.sizer, proportion, flag, border, data);
4199 else if (info.gotSize)
4200 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4201 proportion, flag, border, data);
4202 else
4203 return NULL;
4204 }
4205 SWIGINTERN wxSizerItem *wxSizer_InsertF(wxSizer *self,int before,PyObject *item,wxSizerFlags &flags){
4206
4207 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4208 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4209 if ( info.sizer )
4210 PyObject_SetAttrString(item,"thisown",Py_False);
4211 wxPyEndBlockThreads(blocked);
4212
4213 // Now call the real Insert method if a valid item type was found
4214 if ( info.window )
4215 return self->Insert(before, info.window, flags);
4216 else if ( info.sizer )
4217 return self->Insert(before, info.sizer, flags);
4218 else if (info.gotSize)
4219 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4220 flags.GetProportion(),
4221 flags.GetFlags(),
4222 flags.GetBorderInPixels());
4223 else
4224 return NULL;
4225 }
4226 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4227
4228 wxPyUserData* data = NULL;
4229 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4230 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4231 if ( userData && (info.window || info.sizer || info.gotSize) )
4232 data = new wxPyUserData(userData);
4233 if ( info.sizer )
4234 PyObject_SetAttrString(item,"thisown",Py_False);
4235 wxPyEndBlockThreads(blocked);
4236
4237 // Now call the real Prepend method if a valid item type was found
4238 if ( info.window )
4239 return self->Prepend(info.window, proportion, flag, border, data);
4240 else if ( info.sizer )
4241 return self->Prepend(info.sizer, proportion, flag, border, data);
4242 else if (info.gotSize)
4243 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4244 proportion, flag, border, data);
4245 else
4246 return NULL;
4247 }
4248 SWIGINTERN wxSizerItem *wxSizer_PrependF(wxSizer *self,PyObject *item,wxSizerFlags &flags){
4249
4250 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4251 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4252 if ( info.sizer )
4253 PyObject_SetAttrString(item,"thisown",Py_False);
4254 wxPyEndBlockThreads(blocked);
4255
4256 // Now call the real Add method if a valid item type was found
4257 if ( info.window )
4258 return self->Prepend(info.window, flags);
4259 else if ( info.sizer )
4260 return self->Prepend(info.sizer, flags);
4261 else if (info.gotSize)
4262 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4263 flags.GetProportion(),
4264 flags.GetFlags(),
4265 flags.GetBorderInPixels());
4266 else
4267 return NULL;
4268 }
4269 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4270 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4271 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4272 wxPyEndBlockThreads(blocked);
4273 if ( info.window )
4274 return false; //self->Remove(info.window);
4275 else if ( info.sizer )
4276 return self->Remove(info.sizer);
4277 else if ( info.gotPos )
4278 return self->Remove(info.pos);
4279 else
4280 return false;
4281 }
4282 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4283 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4284 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4285 wxPyEndBlockThreads(blocked);
4286 if ( info.window )
4287 return self->Detach(info.window);
4288 else if ( info.sizer )
4289 return self->Detach(info.sizer);
4290 else if ( info.gotPos )
4291 return self->Detach(info.pos);
4292 else
4293 return false;
4294 }
4295 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item,bool recursive=false){
4296 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4297 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4298 wxPyEndBlockThreads(blocked);
4299 if ( info.window )
4300 return self->GetItem(info.window, recursive);
4301 else if ( info.sizer )
4302 return self->GetItem(info.sizer, recursive);
4303 else if ( info.gotPos )
4304 return self->GetItem(info.pos);
4305 else
4306 return NULL;
4307 }
4308 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4309 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4310 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4311 wxPyEndBlockThreads(blocked);
4312 if ( info.window )
4313 self->SetItemMinSize(info.window, size);
4314 else if ( info.sizer )
4315 self->SetItemMinSize(info.sizer, size);
4316 else if ( info.gotPos )
4317 self->SetItemMinSize(info.pos, size);
4318 }
4319 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4320 wxSizerItemList& list = self->GetChildren();
4321 return wxPy_ConvertList(&list);
4322 }
4323 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4324 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4325 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4326 wxPyEndBlockThreads(blocked);
4327 if ( info.window )
4328 return self->Show(info.window, show, recursive);
4329 else if ( info.sizer )
4330 return self->Show(info.sizer, show, recursive);
4331 else if ( info.gotPos )
4332 return self->Show(info.pos, show);
4333 else
4334 return false;
4335 }
4336 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4337 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4338 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4339 wxPyEndBlockThreads(blocked);
4340 if ( info.window )
4341 return self->IsShown(info.window);
4342 else if ( info.sizer )
4343 return self->IsShown(info.sizer);
4344 else if ( info.gotPos )
4345 return self->IsShown(info.pos);
4346 else
4347 return false;
4348 }
4349
4350 // See pyclasses.h
4351 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4352 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4353 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4354
4355
4356
4357
4358 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4359 {
4360 if (source == Py_None) {
4361 **obj = wxGBPosition(-1,-1);
4362 return true;
4363 }
4364 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4365 }
4366
4367 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4368 {
4369 if (source == Py_None) {
4370 **obj = wxGBSpan(-1,-1);
4371 return true;
4372 }
4373 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4374 }
4375
4376
4377 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4378 wxGBPosition temp, *obj = &temp;
4379 if ( other == Py_None ) return false;
4380 if ( ! wxGBPosition_helper(other, &obj) ) {
4381 PyErr_Clear();
4382 return false;
4383 }
4384 return self->operator==(*obj);
4385 }
4386 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4387 wxGBPosition temp, *obj = &temp;
4388 if ( other == Py_None ) return true;
4389 if ( ! wxGBPosition_helper(other, &obj)) {
4390 PyErr_Clear();
4391 return true;
4392 }
4393 return self->operator!=(*obj);
4394 }
4395 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4396 self->SetRow(row);
4397 self->SetCol(col);
4398 }
4399 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4400 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4401 PyObject* tup = PyTuple_New(2);
4402 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4403 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4404 wxPyEndBlockThreads(blocked);
4405 return tup;
4406 }
4407 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4408 wxGBSpan temp, *obj = &temp;
4409 if ( other == Py_None ) return false;
4410 if ( ! wxGBSpan_helper(other, &obj) ) {
4411 PyErr_Clear();
4412 return false;
4413 }
4414 return self->operator==(*obj);
4415 }
4416 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4417 wxGBSpan temp, *obj = &temp;
4418 if ( other == Py_None ) return true;
4419 if ( ! wxGBSpan_helper(other, &obj)) {
4420 PyErr_Clear();
4421 return true;
4422 }
4423 return self->operator!=(*obj);
4424 }
4425 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4426 self->SetRowspan(rowspan);
4427 self->SetColspan(colspan);
4428 }
4429 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4430 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4431 PyObject* tup = PyTuple_New(2);
4432 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4433 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4434 wxPyEndBlockThreads(blocked);
4435 return tup;
4436 }
4437 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4438 wxPyUserData* data = NULL;
4439 if ( userData ) {
4440 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4441 data = new wxPyUserData(userData);
4442 wxPyEndBlockThreads(blocked);
4443 }
4444 return new wxGBSizerItem(window, pos, span, flag, border, data);
4445 }
4446 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4447 wxPyUserData* data = NULL;
4448 if ( userData ) {
4449 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4450 data = new wxPyUserData(userData);
4451 wxPyEndBlockThreads(blocked);
4452 }
4453 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4454 }
4455 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4456 wxPyUserData* data = NULL;
4457 if ( userData ) {
4458 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4459 data = new wxPyUserData(userData);
4460 wxPyEndBlockThreads(blocked);
4461 }
4462 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4463 }
4464 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4465 int row, col;
4466 self->GetEndPos(row, col);
4467 return wxGBPosition(row, col);
4468 }
4469 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4470
4471 wxPyUserData* data = NULL;
4472 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4473 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4474 if ( userData && (info.window || info.sizer || info.gotSize) )
4475 data = new wxPyUserData(userData);
4476 if ( info.sizer )
4477 PyObject_SetAttrString(item,"thisown",Py_False);
4478 wxPyEndBlockThreads(blocked);
4479
4480 // Now call the real Add method if a valid item type was found
4481 if ( info.window )
4482 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4483 else if ( info.sizer )
4484 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4485 else if (info.gotSize)
4486 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4487 pos, span, flag, border, data);
4488 return NULL;
4489 }
4490
4491
4492 #ifdef __cplusplus
4493 extern "C" {
4494 #endif
4495 SWIGINTERN int EmptyString_set(PyObject *) {
4496 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4497 return 1;
4498 }
4499
4500
4501 SWIGINTERN PyObject *EmptyString_get(void) {
4502 PyObject *pyobj = 0;
4503
4504 {
4505 #if wxUSE_UNICODE
4506 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4507 #else
4508 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4509 #endif
4510 }
4511 return pyobj;
4512 }
4513
4514
4515 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4516 PyObject *resultobj = 0;
4517 wxObject *arg1 = (wxObject *) 0 ;
4518 wxString result;
4519 void *argp1 = 0 ;
4520 int res1 = 0 ;
4521 PyObject *swig_obj[1] ;
4522
4523 if (!args) SWIG_fail;
4524 swig_obj[0] = args;
4525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4526 if (!SWIG_IsOK(res1)) {
4527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4528 }
4529 arg1 = reinterpret_cast< wxObject * >(argp1);
4530 {
4531 PyThreadState* __tstate = wxPyBeginAllowThreads();
4532 result = wxObject_GetClassName(arg1);
4533 wxPyEndAllowThreads(__tstate);
4534 if (PyErr_Occurred()) SWIG_fail;
4535 }
4536 {
4537 #if wxUSE_UNICODE
4538 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4539 #else
4540 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4541 #endif
4542 }
4543 return resultobj;
4544 fail:
4545 return NULL;
4546 }
4547
4548
4549 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4550 PyObject *resultobj = 0;
4551 wxObject *arg1 = (wxObject *) 0 ;
4552 void *argp1 = 0 ;
4553 int res1 = 0 ;
4554 PyObject *swig_obj[1] ;
4555
4556 if (!args) SWIG_fail;
4557 swig_obj[0] = args;
4558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4559 if (!SWIG_IsOK(res1)) {
4560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4561 }
4562 arg1 = reinterpret_cast< wxObject * >(argp1);
4563 {
4564 PyThreadState* __tstate = wxPyBeginAllowThreads();
4565 wxObject_Destroy(arg1);
4566 wxPyEndAllowThreads(__tstate);
4567 if (PyErr_Occurred()) SWIG_fail;
4568 }
4569 resultobj = SWIG_Py_Void();
4570 return resultobj;
4571 fail:
4572 return NULL;
4573 }
4574
4575
4576 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4577 PyObject *resultobj = 0;
4578 wxObject *arg1 = (wxObject *) 0 ;
4579 wxObject *arg2 = 0 ;
4580 bool result;
4581 void *argp1 = 0 ;
4582 int res1 = 0 ;
4583 void *argp2 = 0 ;
4584 int res2 = 0 ;
4585 PyObject * obj0 = 0 ;
4586 PyObject * obj1 = 0 ;
4587 char * kwnames[] = {
4588 (char *) "self",(char *) "p", NULL
4589 };
4590
4591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4593 if (!SWIG_IsOK(res1)) {
4594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4595 }
4596 arg1 = reinterpret_cast< wxObject * >(argp1);
4597 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4598 if (!SWIG_IsOK(res2)) {
4599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4600 }
4601 if (!argp2) {
4602 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4603 }
4604 arg2 = reinterpret_cast< wxObject * >(argp2);
4605 {
4606 PyThreadState* __tstate = wxPyBeginAllowThreads();
4607 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4608 wxPyEndAllowThreads(__tstate);
4609 if (PyErr_Occurred()) SWIG_fail;
4610 }
4611 {
4612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4613 }
4614 return resultobj;
4615 fail:
4616 return NULL;
4617 }
4618
4619
4620 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4621 PyObject *obj;
4622 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4623 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4624 return SWIG_Py_Void();
4625 }
4626
4627 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4628 PyObject *resultobj = 0;
4629 wxSize *arg1 = (wxSize *) 0 ;
4630 int arg2 ;
4631 void *argp1 = 0 ;
4632 int res1 = 0 ;
4633 int val2 ;
4634 int ecode2 = 0 ;
4635 PyObject *swig_obj[2] ;
4636
4637 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4639 if (!SWIG_IsOK(res1)) {
4640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4641 }
4642 arg1 = reinterpret_cast< wxSize * >(argp1);
4643 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4644 if (!SWIG_IsOK(ecode2)) {
4645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4646 }
4647 arg2 = static_cast< int >(val2);
4648 if (arg1) (arg1)->x = arg2;
4649
4650 resultobj = SWIG_Py_Void();
4651 return resultobj;
4652 fail:
4653 return NULL;
4654 }
4655
4656
4657 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4658 PyObject *resultobj = 0;
4659 wxSize *arg1 = (wxSize *) 0 ;
4660 int result;
4661 void *argp1 = 0 ;
4662 int res1 = 0 ;
4663 PyObject *swig_obj[1] ;
4664
4665 if (!args) SWIG_fail;
4666 swig_obj[0] = args;
4667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4668 if (!SWIG_IsOK(res1)) {
4669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4670 }
4671 arg1 = reinterpret_cast< wxSize * >(argp1);
4672 result = (int) ((arg1)->x);
4673 resultobj = SWIG_From_int(static_cast< int >(result));
4674 return resultobj;
4675 fail:
4676 return NULL;
4677 }
4678
4679
4680 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4681 PyObject *resultobj = 0;
4682 wxSize *arg1 = (wxSize *) 0 ;
4683 int arg2 ;
4684 void *argp1 = 0 ;
4685 int res1 = 0 ;
4686 int val2 ;
4687 int ecode2 = 0 ;
4688 PyObject *swig_obj[2] ;
4689
4690 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4692 if (!SWIG_IsOK(res1)) {
4693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4694 }
4695 arg1 = reinterpret_cast< wxSize * >(argp1);
4696 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4697 if (!SWIG_IsOK(ecode2)) {
4698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4699 }
4700 arg2 = static_cast< int >(val2);
4701 if (arg1) (arg1)->y = arg2;
4702
4703 resultobj = SWIG_Py_Void();
4704 return resultobj;
4705 fail:
4706 return NULL;
4707 }
4708
4709
4710 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4711 PyObject *resultobj = 0;
4712 wxSize *arg1 = (wxSize *) 0 ;
4713 int result;
4714 void *argp1 = 0 ;
4715 int res1 = 0 ;
4716 PyObject *swig_obj[1] ;
4717
4718 if (!args) SWIG_fail;
4719 swig_obj[0] = args;
4720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4721 if (!SWIG_IsOK(res1)) {
4722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4723 }
4724 arg1 = reinterpret_cast< wxSize * >(argp1);
4725 result = (int) ((arg1)->y);
4726 resultobj = SWIG_From_int(static_cast< int >(result));
4727 return resultobj;
4728 fail:
4729 return NULL;
4730 }
4731
4732
4733 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4734 PyObject *resultobj = 0;
4735 int arg1 = (int) 0 ;
4736 int arg2 = (int) 0 ;
4737 wxSize *result = 0 ;
4738 int val1 ;
4739 int ecode1 = 0 ;
4740 int val2 ;
4741 int ecode2 = 0 ;
4742 PyObject * obj0 = 0 ;
4743 PyObject * obj1 = 0 ;
4744 char * kwnames[] = {
4745 (char *) "w",(char *) "h", NULL
4746 };
4747
4748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4749 if (obj0) {
4750 ecode1 = SWIG_AsVal_int(obj0, &val1);
4751 if (!SWIG_IsOK(ecode1)) {
4752 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4753 }
4754 arg1 = static_cast< int >(val1);
4755 }
4756 if (obj1) {
4757 ecode2 = SWIG_AsVal_int(obj1, &val2);
4758 if (!SWIG_IsOK(ecode2)) {
4759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4760 }
4761 arg2 = static_cast< int >(val2);
4762 }
4763 {
4764 result = (wxSize *)new wxSize(arg1,arg2);
4765 if (PyErr_Occurred()) SWIG_fail;
4766 }
4767 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4768 return resultobj;
4769 fail:
4770 return NULL;
4771 }
4772
4773
4774 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4775 PyObject *resultobj = 0;
4776 wxSize *arg1 = (wxSize *) 0 ;
4777 void *argp1 = 0 ;
4778 int res1 = 0 ;
4779 PyObject *swig_obj[1] ;
4780
4781 if (!args) SWIG_fail;
4782 swig_obj[0] = args;
4783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4784 if (!SWIG_IsOK(res1)) {
4785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4786 }
4787 arg1 = reinterpret_cast< wxSize * >(argp1);
4788 {
4789 delete arg1;
4790
4791 if (PyErr_Occurred()) SWIG_fail;
4792 }
4793 resultobj = SWIG_Py_Void();
4794 return resultobj;
4795 fail:
4796 return NULL;
4797 }
4798
4799
4800 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4801 PyObject *resultobj = 0;
4802 wxSize *arg1 = (wxSize *) 0 ;
4803 PyObject *arg2 = (PyObject *) 0 ;
4804 bool result;
4805 void *argp1 = 0 ;
4806 int res1 = 0 ;
4807 PyObject * obj0 = 0 ;
4808 PyObject * obj1 = 0 ;
4809 char * kwnames[] = {
4810 (char *) "self",(char *) "other", NULL
4811 };
4812
4813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4815 if (!SWIG_IsOK(res1)) {
4816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4817 }
4818 arg1 = reinterpret_cast< wxSize * >(argp1);
4819 arg2 = obj1;
4820 {
4821 result = (bool)wxSize___eq__(arg1,arg2);
4822 if (PyErr_Occurred()) SWIG_fail;
4823 }
4824 {
4825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4826 }
4827 return resultobj;
4828 fail:
4829 return NULL;
4830 }
4831
4832
4833 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4834 PyObject *resultobj = 0;
4835 wxSize *arg1 = (wxSize *) 0 ;
4836 PyObject *arg2 = (PyObject *) 0 ;
4837 bool result;
4838 void *argp1 = 0 ;
4839 int res1 = 0 ;
4840 PyObject * obj0 = 0 ;
4841 PyObject * obj1 = 0 ;
4842 char * kwnames[] = {
4843 (char *) "self",(char *) "other", NULL
4844 };
4845
4846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4848 if (!SWIG_IsOK(res1)) {
4849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4850 }
4851 arg1 = reinterpret_cast< wxSize * >(argp1);
4852 arg2 = obj1;
4853 {
4854 result = (bool)wxSize___ne__(arg1,arg2);
4855 if (PyErr_Occurred()) SWIG_fail;
4856 }
4857 {
4858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4859 }
4860 return resultobj;
4861 fail:
4862 return NULL;
4863 }
4864
4865
4866 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4867 PyObject *resultobj = 0;
4868 wxSize *arg1 = (wxSize *) 0 ;
4869 wxSize *arg2 = 0 ;
4870 wxSize result;
4871 void *argp1 = 0 ;
4872 int res1 = 0 ;
4873 wxSize temp2 ;
4874 PyObject * obj0 = 0 ;
4875 PyObject * obj1 = 0 ;
4876 char * kwnames[] = {
4877 (char *) "self",(char *) "sz", NULL
4878 };
4879
4880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4882 if (!SWIG_IsOK(res1)) {
4883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4884 }
4885 arg1 = reinterpret_cast< wxSize * >(argp1);
4886 {
4887 arg2 = &temp2;
4888 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4889 }
4890 {
4891 result = (arg1)->operator +((wxSize const &)*arg2);
4892 if (PyErr_Occurred()) SWIG_fail;
4893 }
4894 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4895 return resultobj;
4896 fail:
4897 return NULL;
4898 }
4899
4900
4901 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4902 PyObject *resultobj = 0;
4903 wxSize *arg1 = (wxSize *) 0 ;
4904 wxSize *arg2 = 0 ;
4905 wxSize result;
4906 void *argp1 = 0 ;
4907 int res1 = 0 ;
4908 wxSize temp2 ;
4909 PyObject * obj0 = 0 ;
4910 PyObject * obj1 = 0 ;
4911 char * kwnames[] = {
4912 (char *) "self",(char *) "sz", NULL
4913 };
4914
4915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4917 if (!SWIG_IsOK(res1)) {
4918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4919 }
4920 arg1 = reinterpret_cast< wxSize * >(argp1);
4921 {
4922 arg2 = &temp2;
4923 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4924 }
4925 {
4926 result = (arg1)->operator -((wxSize const &)*arg2);
4927 if (PyErr_Occurred()) SWIG_fail;
4928 }
4929 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4930 return resultobj;
4931 fail:
4932 return NULL;
4933 }
4934
4935
4936 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4937 PyObject *resultobj = 0;
4938 wxSize *arg1 = (wxSize *) 0 ;
4939 wxSize *arg2 = 0 ;
4940 void *argp1 = 0 ;
4941 int res1 = 0 ;
4942 wxSize temp2 ;
4943 PyObject * obj0 = 0 ;
4944 PyObject * obj1 = 0 ;
4945 char * kwnames[] = {
4946 (char *) "self",(char *) "sz", NULL
4947 };
4948
4949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4951 if (!SWIG_IsOK(res1)) {
4952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4953 }
4954 arg1 = reinterpret_cast< wxSize * >(argp1);
4955 {
4956 arg2 = &temp2;
4957 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4958 }
4959 {
4960 (arg1)->IncTo((wxSize const &)*arg2);
4961 if (PyErr_Occurred()) SWIG_fail;
4962 }
4963 resultobj = SWIG_Py_Void();
4964 return resultobj;
4965 fail:
4966 return NULL;
4967 }
4968
4969
4970 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4971 PyObject *resultobj = 0;
4972 wxSize *arg1 = (wxSize *) 0 ;
4973 wxSize *arg2 = 0 ;
4974 void *argp1 = 0 ;
4975 int res1 = 0 ;
4976 wxSize temp2 ;
4977 PyObject * obj0 = 0 ;
4978 PyObject * obj1 = 0 ;
4979 char * kwnames[] = {
4980 (char *) "self",(char *) "sz", NULL
4981 };
4982
4983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4985 if (!SWIG_IsOK(res1)) {
4986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4987 }
4988 arg1 = reinterpret_cast< wxSize * >(argp1);
4989 {
4990 arg2 = &temp2;
4991 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4992 }
4993 {
4994 (arg1)->DecTo((wxSize const &)*arg2);
4995 if (PyErr_Occurred()) SWIG_fail;
4996 }
4997 resultobj = SWIG_Py_Void();
4998 return resultobj;
4999 fail:
5000 return NULL;
5001 }
5002
5003
5004 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5005 PyObject *resultobj = 0;
5006 wxSize *arg1 = (wxSize *) 0 ;
5007 int arg2 ;
5008 int arg3 ;
5009 void *argp1 = 0 ;
5010 int res1 = 0 ;
5011 int val2 ;
5012 int ecode2 = 0 ;
5013 int val3 ;
5014 int ecode3 = 0 ;
5015 PyObject * obj0 = 0 ;
5016 PyObject * obj1 = 0 ;
5017 PyObject * obj2 = 0 ;
5018 char * kwnames[] = {
5019 (char *) "self",(char *) "dx",(char *) "dy", NULL
5020 };
5021
5022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5024 if (!SWIG_IsOK(res1)) {
5025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
5026 }
5027 arg1 = reinterpret_cast< wxSize * >(argp1);
5028 ecode2 = SWIG_AsVal_int(obj1, &val2);
5029 if (!SWIG_IsOK(ecode2)) {
5030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
5031 }
5032 arg2 = static_cast< int >(val2);
5033 ecode3 = SWIG_AsVal_int(obj2, &val3);
5034 if (!SWIG_IsOK(ecode3)) {
5035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
5036 }
5037 arg3 = static_cast< int >(val3);
5038 {
5039 (arg1)->IncBy(arg2,arg3);
5040 if (PyErr_Occurred()) SWIG_fail;
5041 }
5042 resultobj = SWIG_Py_Void();
5043 return resultobj;
5044 fail:
5045 return NULL;
5046 }
5047
5048
5049 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5050 PyObject *resultobj = 0;
5051 wxSize *arg1 = (wxSize *) 0 ;
5052 int arg2 ;
5053 int arg3 ;
5054 void *argp1 = 0 ;
5055 int res1 = 0 ;
5056 int val2 ;
5057 int ecode2 = 0 ;
5058 int val3 ;
5059 int ecode3 = 0 ;
5060 PyObject * obj0 = 0 ;
5061 PyObject * obj1 = 0 ;
5062 PyObject * obj2 = 0 ;
5063 char * kwnames[] = {
5064 (char *) "self",(char *) "dx",(char *) "dy", NULL
5065 };
5066
5067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5069 if (!SWIG_IsOK(res1)) {
5070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
5071 }
5072 arg1 = reinterpret_cast< wxSize * >(argp1);
5073 ecode2 = SWIG_AsVal_int(obj1, &val2);
5074 if (!SWIG_IsOK(ecode2)) {
5075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5076 }
5077 arg2 = static_cast< int >(val2);
5078 ecode3 = SWIG_AsVal_int(obj2, &val3);
5079 if (!SWIG_IsOK(ecode3)) {
5080 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5081 }
5082 arg3 = static_cast< int >(val3);
5083 {
5084 (arg1)->DecBy(arg2,arg3);
5085 if (PyErr_Occurred()) SWIG_fail;
5086 }
5087 resultobj = SWIG_Py_Void();
5088 return resultobj;
5089 fail:
5090 return NULL;
5091 }
5092
5093
5094 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5095 PyObject *resultobj = 0;
5096 wxSize *arg1 = (wxSize *) 0 ;
5097 float arg2 ;
5098 float arg3 ;
5099 void *argp1 = 0 ;
5100 int res1 = 0 ;
5101 float val2 ;
5102 int ecode2 = 0 ;
5103 float val3 ;
5104 int ecode3 = 0 ;
5105 PyObject * obj0 = 0 ;
5106 PyObject * obj1 = 0 ;
5107 PyObject * obj2 = 0 ;
5108 char * kwnames[] = {
5109 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5110 };
5111
5112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5114 if (!SWIG_IsOK(res1)) {
5115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5116 }
5117 arg1 = reinterpret_cast< wxSize * >(argp1);
5118 ecode2 = SWIG_AsVal_float(obj1, &val2);
5119 if (!SWIG_IsOK(ecode2)) {
5120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5121 }
5122 arg2 = static_cast< float >(val2);
5123 ecode3 = SWIG_AsVal_float(obj2, &val3);
5124 if (!SWIG_IsOK(ecode3)) {
5125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5126 }
5127 arg3 = static_cast< float >(val3);
5128 {
5129 (arg1)->Scale(arg2,arg3);
5130 if (PyErr_Occurred()) SWIG_fail;
5131 }
5132 resultobj = SWIG_Py_Void();
5133 return resultobj;
5134 fail:
5135 return NULL;
5136 }
5137
5138
5139 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5140 PyObject *resultobj = 0;
5141 wxSize *arg1 = (wxSize *) 0 ;
5142 int arg2 ;
5143 int arg3 ;
5144 void *argp1 = 0 ;
5145 int res1 = 0 ;
5146 int val2 ;
5147 int ecode2 = 0 ;
5148 int val3 ;
5149 int ecode3 = 0 ;
5150 PyObject * obj0 = 0 ;
5151 PyObject * obj1 = 0 ;
5152 PyObject * obj2 = 0 ;
5153 char * kwnames[] = {
5154 (char *) "self",(char *) "w",(char *) "h", NULL
5155 };
5156
5157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5159 if (!SWIG_IsOK(res1)) {
5160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5161 }
5162 arg1 = reinterpret_cast< wxSize * >(argp1);
5163 ecode2 = SWIG_AsVal_int(obj1, &val2);
5164 if (!SWIG_IsOK(ecode2)) {
5165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5166 }
5167 arg2 = static_cast< int >(val2);
5168 ecode3 = SWIG_AsVal_int(obj2, &val3);
5169 if (!SWIG_IsOK(ecode3)) {
5170 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5171 }
5172 arg3 = static_cast< int >(val3);
5173 {
5174 (arg1)->Set(arg2,arg3);
5175 if (PyErr_Occurred()) SWIG_fail;
5176 }
5177 resultobj = SWIG_Py_Void();
5178 return resultobj;
5179 fail:
5180 return NULL;
5181 }
5182
5183
5184 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5185 PyObject *resultobj = 0;
5186 wxSize *arg1 = (wxSize *) 0 ;
5187 int arg2 ;
5188 void *argp1 = 0 ;
5189 int res1 = 0 ;
5190 int val2 ;
5191 int ecode2 = 0 ;
5192 PyObject * obj0 = 0 ;
5193 PyObject * obj1 = 0 ;
5194 char * kwnames[] = {
5195 (char *) "self",(char *) "w", NULL
5196 };
5197
5198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5200 if (!SWIG_IsOK(res1)) {
5201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5202 }
5203 arg1 = reinterpret_cast< wxSize * >(argp1);
5204 ecode2 = SWIG_AsVal_int(obj1, &val2);
5205 if (!SWIG_IsOK(ecode2)) {
5206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5207 }
5208 arg2 = static_cast< int >(val2);
5209 {
5210 (arg1)->SetWidth(arg2);
5211 if (PyErr_Occurred()) SWIG_fail;
5212 }
5213 resultobj = SWIG_Py_Void();
5214 return resultobj;
5215 fail:
5216 return NULL;
5217 }
5218
5219
5220 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5221 PyObject *resultobj = 0;
5222 wxSize *arg1 = (wxSize *) 0 ;
5223 int arg2 ;
5224 void *argp1 = 0 ;
5225 int res1 = 0 ;
5226 int val2 ;
5227 int ecode2 = 0 ;
5228 PyObject * obj0 = 0 ;
5229 PyObject * obj1 = 0 ;
5230 char * kwnames[] = {
5231 (char *) "self",(char *) "h", NULL
5232 };
5233
5234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5236 if (!SWIG_IsOK(res1)) {
5237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5238 }
5239 arg1 = reinterpret_cast< wxSize * >(argp1);
5240 ecode2 = SWIG_AsVal_int(obj1, &val2);
5241 if (!SWIG_IsOK(ecode2)) {
5242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5243 }
5244 arg2 = static_cast< int >(val2);
5245 {
5246 (arg1)->SetHeight(arg2);
5247 if (PyErr_Occurred()) SWIG_fail;
5248 }
5249 resultobj = SWIG_Py_Void();
5250 return resultobj;
5251 fail:
5252 return NULL;
5253 }
5254
5255
5256 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5257 PyObject *resultobj = 0;
5258 wxSize *arg1 = (wxSize *) 0 ;
5259 int result;
5260 void *argp1 = 0 ;
5261 int res1 = 0 ;
5262 PyObject *swig_obj[1] ;
5263
5264 if (!args) SWIG_fail;
5265 swig_obj[0] = args;
5266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5267 if (!SWIG_IsOK(res1)) {
5268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5269 }
5270 arg1 = reinterpret_cast< wxSize * >(argp1);
5271 {
5272 result = (int)((wxSize const *)arg1)->GetWidth();
5273 if (PyErr_Occurred()) SWIG_fail;
5274 }
5275 resultobj = SWIG_From_int(static_cast< int >(result));
5276 return resultobj;
5277 fail:
5278 return NULL;
5279 }
5280
5281
5282 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5283 PyObject *resultobj = 0;
5284 wxSize *arg1 = (wxSize *) 0 ;
5285 int result;
5286 void *argp1 = 0 ;
5287 int res1 = 0 ;
5288 PyObject *swig_obj[1] ;
5289
5290 if (!args) SWIG_fail;
5291 swig_obj[0] = args;
5292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5293 if (!SWIG_IsOK(res1)) {
5294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5295 }
5296 arg1 = reinterpret_cast< wxSize * >(argp1);
5297 {
5298 result = (int)((wxSize const *)arg1)->GetHeight();
5299 if (PyErr_Occurred()) SWIG_fail;
5300 }
5301 resultobj = SWIG_From_int(static_cast< int >(result));
5302 return resultobj;
5303 fail:
5304 return NULL;
5305 }
5306
5307
5308 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5309 PyObject *resultobj = 0;
5310 wxSize *arg1 = (wxSize *) 0 ;
5311 bool result;
5312 void *argp1 = 0 ;
5313 int res1 = 0 ;
5314 PyObject *swig_obj[1] ;
5315
5316 if (!args) SWIG_fail;
5317 swig_obj[0] = args;
5318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5319 if (!SWIG_IsOK(res1)) {
5320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5321 }
5322 arg1 = reinterpret_cast< wxSize * >(argp1);
5323 {
5324 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5325 if (PyErr_Occurred()) SWIG_fail;
5326 }
5327 {
5328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5329 }
5330 return resultobj;
5331 fail:
5332 return NULL;
5333 }
5334
5335
5336 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5337 PyObject *resultobj = 0;
5338 wxSize *arg1 = (wxSize *) 0 ;
5339 wxSize *arg2 = 0 ;
5340 void *argp1 = 0 ;
5341 int res1 = 0 ;
5342 wxSize temp2 ;
5343 PyObject * obj0 = 0 ;
5344 PyObject * obj1 = 0 ;
5345 char * kwnames[] = {
5346 (char *) "self",(char *) "size", NULL
5347 };
5348
5349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5351 if (!SWIG_IsOK(res1)) {
5352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5353 }
5354 arg1 = reinterpret_cast< wxSize * >(argp1);
5355 {
5356 arg2 = &temp2;
5357 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5358 }
5359 {
5360 (arg1)->SetDefaults((wxSize const &)*arg2);
5361 if (PyErr_Occurred()) SWIG_fail;
5362 }
5363 resultobj = SWIG_Py_Void();
5364 return resultobj;
5365 fail:
5366 return NULL;
5367 }
5368
5369
5370 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5371 PyObject *resultobj = 0;
5372 wxSize *arg1 = (wxSize *) 0 ;
5373 PyObject *result = 0 ;
5374 void *argp1 = 0 ;
5375 int res1 = 0 ;
5376 PyObject *swig_obj[1] ;
5377
5378 if (!args) SWIG_fail;
5379 swig_obj[0] = args;
5380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5381 if (!SWIG_IsOK(res1)) {
5382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5383 }
5384 arg1 = reinterpret_cast< wxSize * >(argp1);
5385 {
5386 result = (PyObject *)wxSize_Get(arg1);
5387 if (PyErr_Occurred()) SWIG_fail;
5388 }
5389 resultobj = result;
5390 return resultobj;
5391 fail:
5392 return NULL;
5393 }
5394
5395
5396 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5397 PyObject *obj;
5398 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5399 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5400 return SWIG_Py_Void();
5401 }
5402
5403 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5404 return SWIG_Python_InitShadowInstance(args);
5405 }
5406
5407 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5408 PyObject *resultobj = 0;
5409 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5410 double arg2 ;
5411 void *argp1 = 0 ;
5412 int res1 = 0 ;
5413 double val2 ;
5414 int ecode2 = 0 ;
5415 PyObject *swig_obj[2] ;
5416
5417 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5419 if (!SWIG_IsOK(res1)) {
5420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5421 }
5422 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5423 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5424 if (!SWIG_IsOK(ecode2)) {
5425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5426 }
5427 arg2 = static_cast< double >(val2);
5428 if (arg1) (arg1)->x = arg2;
5429
5430 resultobj = SWIG_Py_Void();
5431 return resultobj;
5432 fail:
5433 return NULL;
5434 }
5435
5436
5437 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5438 PyObject *resultobj = 0;
5439 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5440 double result;
5441 void *argp1 = 0 ;
5442 int res1 = 0 ;
5443 PyObject *swig_obj[1] ;
5444
5445 if (!args) SWIG_fail;
5446 swig_obj[0] = args;
5447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5448 if (!SWIG_IsOK(res1)) {
5449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5450 }
5451 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5452 result = (double) ((arg1)->x);
5453 resultobj = SWIG_From_double(static_cast< double >(result));
5454 return resultobj;
5455 fail:
5456 return NULL;
5457 }
5458
5459
5460 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5461 PyObject *resultobj = 0;
5462 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5463 double arg2 ;
5464 void *argp1 = 0 ;
5465 int res1 = 0 ;
5466 double val2 ;
5467 int ecode2 = 0 ;
5468 PyObject *swig_obj[2] ;
5469
5470 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5472 if (!SWIG_IsOK(res1)) {
5473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5474 }
5475 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5476 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5477 if (!SWIG_IsOK(ecode2)) {
5478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5479 }
5480 arg2 = static_cast< double >(val2);
5481 if (arg1) (arg1)->y = arg2;
5482
5483 resultobj = SWIG_Py_Void();
5484 return resultobj;
5485 fail:
5486 return NULL;
5487 }
5488
5489
5490 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5491 PyObject *resultobj = 0;
5492 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5493 double result;
5494 void *argp1 = 0 ;
5495 int res1 = 0 ;
5496 PyObject *swig_obj[1] ;
5497
5498 if (!args) SWIG_fail;
5499 swig_obj[0] = args;
5500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5501 if (!SWIG_IsOK(res1)) {
5502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5503 }
5504 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5505 result = (double) ((arg1)->y);
5506 resultobj = SWIG_From_double(static_cast< double >(result));
5507 return resultobj;
5508 fail:
5509 return NULL;
5510 }
5511
5512
5513 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5514 PyObject *resultobj = 0;
5515 double arg1 = (double) 0.0 ;
5516 double arg2 = (double) 0.0 ;
5517 wxRealPoint *result = 0 ;
5518 double val1 ;
5519 int ecode1 = 0 ;
5520 double val2 ;
5521 int ecode2 = 0 ;
5522 PyObject * obj0 = 0 ;
5523 PyObject * obj1 = 0 ;
5524 char * kwnames[] = {
5525 (char *) "x",(char *) "y", NULL
5526 };
5527
5528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5529 if (obj0) {
5530 ecode1 = SWIG_AsVal_double(obj0, &val1);
5531 if (!SWIG_IsOK(ecode1)) {
5532 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5533 }
5534 arg1 = static_cast< double >(val1);
5535 }
5536 if (obj1) {
5537 ecode2 = SWIG_AsVal_double(obj1, &val2);
5538 if (!SWIG_IsOK(ecode2)) {
5539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5540 }
5541 arg2 = static_cast< double >(val2);
5542 }
5543 {
5544 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5545 if (PyErr_Occurred()) SWIG_fail;
5546 }
5547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5548 return resultobj;
5549 fail:
5550 return NULL;
5551 }
5552
5553
5554 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5555 PyObject *resultobj = 0;
5556 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5557 void *argp1 = 0 ;
5558 int res1 = 0 ;
5559 PyObject *swig_obj[1] ;
5560
5561 if (!args) SWIG_fail;
5562 swig_obj[0] = args;
5563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5564 if (!SWIG_IsOK(res1)) {
5565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5566 }
5567 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5568 {
5569 delete arg1;
5570
5571 if (PyErr_Occurred()) SWIG_fail;
5572 }
5573 resultobj = SWIG_Py_Void();
5574 return resultobj;
5575 fail:
5576 return NULL;
5577 }
5578
5579
5580 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5581 PyObject *resultobj = 0;
5582 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5583 PyObject *arg2 = (PyObject *) 0 ;
5584 bool result;
5585 void *argp1 = 0 ;
5586 int res1 = 0 ;
5587 PyObject * obj0 = 0 ;
5588 PyObject * obj1 = 0 ;
5589 char * kwnames[] = {
5590 (char *) "self",(char *) "other", NULL
5591 };
5592
5593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5595 if (!SWIG_IsOK(res1)) {
5596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5597 }
5598 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5599 arg2 = obj1;
5600 {
5601 result = (bool)wxRealPoint___eq__(arg1,arg2);
5602 if (PyErr_Occurred()) SWIG_fail;
5603 }
5604 {
5605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5606 }
5607 return resultobj;
5608 fail:
5609 return NULL;
5610 }
5611
5612
5613 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5614 PyObject *resultobj = 0;
5615 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5616 PyObject *arg2 = (PyObject *) 0 ;
5617 bool result;
5618 void *argp1 = 0 ;
5619 int res1 = 0 ;
5620 PyObject * obj0 = 0 ;
5621 PyObject * obj1 = 0 ;
5622 char * kwnames[] = {
5623 (char *) "self",(char *) "other", NULL
5624 };
5625
5626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5628 if (!SWIG_IsOK(res1)) {
5629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5630 }
5631 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5632 arg2 = obj1;
5633 {
5634 result = (bool)wxRealPoint___ne__(arg1,arg2);
5635 if (PyErr_Occurred()) SWIG_fail;
5636 }
5637 {
5638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5639 }
5640 return resultobj;
5641 fail:
5642 return NULL;
5643 }
5644
5645
5646 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5647 PyObject *resultobj = 0;
5648 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5649 wxRealPoint *arg2 = 0 ;
5650 wxRealPoint result;
5651 void *argp1 = 0 ;
5652 int res1 = 0 ;
5653 wxRealPoint temp2 ;
5654 PyObject * obj0 = 0 ;
5655 PyObject * obj1 = 0 ;
5656 char * kwnames[] = {
5657 (char *) "self",(char *) "pt", NULL
5658 };
5659
5660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5662 if (!SWIG_IsOK(res1)) {
5663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5664 }
5665 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5666 {
5667 arg2 = &temp2;
5668 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5669 }
5670 {
5671 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5672 if (PyErr_Occurred()) SWIG_fail;
5673 }
5674 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5675 return resultobj;
5676 fail:
5677 return NULL;
5678 }
5679
5680
5681 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5682 PyObject *resultobj = 0;
5683 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5684 wxRealPoint *arg2 = 0 ;
5685 wxRealPoint result;
5686 void *argp1 = 0 ;
5687 int res1 = 0 ;
5688 wxRealPoint temp2 ;
5689 PyObject * obj0 = 0 ;
5690 PyObject * obj1 = 0 ;
5691 char * kwnames[] = {
5692 (char *) "self",(char *) "pt", NULL
5693 };
5694
5695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5697 if (!SWIG_IsOK(res1)) {
5698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5699 }
5700 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5701 {
5702 arg2 = &temp2;
5703 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5704 }
5705 {
5706 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5707 if (PyErr_Occurred()) SWIG_fail;
5708 }
5709 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5710 return resultobj;
5711 fail:
5712 return NULL;
5713 }
5714
5715
5716 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5717 PyObject *resultobj = 0;
5718 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5719 double arg2 ;
5720 double arg3 ;
5721 void *argp1 = 0 ;
5722 int res1 = 0 ;
5723 double val2 ;
5724 int ecode2 = 0 ;
5725 double val3 ;
5726 int ecode3 = 0 ;
5727 PyObject * obj0 = 0 ;
5728 PyObject * obj1 = 0 ;
5729 PyObject * obj2 = 0 ;
5730 char * kwnames[] = {
5731 (char *) "self",(char *) "x",(char *) "y", NULL
5732 };
5733
5734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5736 if (!SWIG_IsOK(res1)) {
5737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5738 }
5739 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5740 ecode2 = SWIG_AsVal_double(obj1, &val2);
5741 if (!SWIG_IsOK(ecode2)) {
5742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5743 }
5744 arg2 = static_cast< double >(val2);
5745 ecode3 = SWIG_AsVal_double(obj2, &val3);
5746 if (!SWIG_IsOK(ecode3)) {
5747 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5748 }
5749 arg3 = static_cast< double >(val3);
5750 {
5751 wxRealPoint_Set(arg1,arg2,arg3);
5752 if (PyErr_Occurred()) SWIG_fail;
5753 }
5754 resultobj = SWIG_Py_Void();
5755 return resultobj;
5756 fail:
5757 return NULL;
5758 }
5759
5760
5761 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5762 PyObject *resultobj = 0;
5763 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5764 PyObject *result = 0 ;
5765 void *argp1 = 0 ;
5766 int res1 = 0 ;
5767 PyObject *swig_obj[1] ;
5768
5769 if (!args) SWIG_fail;
5770 swig_obj[0] = args;
5771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5772 if (!SWIG_IsOK(res1)) {
5773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5774 }
5775 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5776 {
5777 result = (PyObject *)wxRealPoint_Get(arg1);
5778 if (PyErr_Occurred()) SWIG_fail;
5779 }
5780 resultobj = result;
5781 return resultobj;
5782 fail:
5783 return NULL;
5784 }
5785
5786
5787 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5788 PyObject *obj;
5789 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5790 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5791 return SWIG_Py_Void();
5792 }
5793
5794 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5795 return SWIG_Python_InitShadowInstance(args);
5796 }
5797
5798 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5799 PyObject *resultobj = 0;
5800 wxPoint *arg1 = (wxPoint *) 0 ;
5801 int arg2 ;
5802 void *argp1 = 0 ;
5803 int res1 = 0 ;
5804 int val2 ;
5805 int ecode2 = 0 ;
5806 PyObject *swig_obj[2] ;
5807
5808 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5810 if (!SWIG_IsOK(res1)) {
5811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5812 }
5813 arg1 = reinterpret_cast< wxPoint * >(argp1);
5814 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5815 if (!SWIG_IsOK(ecode2)) {
5816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5817 }
5818 arg2 = static_cast< int >(val2);
5819 if (arg1) (arg1)->x = arg2;
5820
5821 resultobj = SWIG_Py_Void();
5822 return resultobj;
5823 fail:
5824 return NULL;
5825 }
5826
5827
5828 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5829 PyObject *resultobj = 0;
5830 wxPoint *arg1 = (wxPoint *) 0 ;
5831 int result;
5832 void *argp1 = 0 ;
5833 int res1 = 0 ;
5834 PyObject *swig_obj[1] ;
5835
5836 if (!args) SWIG_fail;
5837 swig_obj[0] = args;
5838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5839 if (!SWIG_IsOK(res1)) {
5840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5841 }
5842 arg1 = reinterpret_cast< wxPoint * >(argp1);
5843 result = (int) ((arg1)->x);
5844 resultobj = SWIG_From_int(static_cast< int >(result));
5845 return resultobj;
5846 fail:
5847 return NULL;
5848 }
5849
5850
5851 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5852 PyObject *resultobj = 0;
5853 wxPoint *arg1 = (wxPoint *) 0 ;
5854 int arg2 ;
5855 void *argp1 = 0 ;
5856 int res1 = 0 ;
5857 int val2 ;
5858 int ecode2 = 0 ;
5859 PyObject *swig_obj[2] ;
5860
5861 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5863 if (!SWIG_IsOK(res1)) {
5864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5865 }
5866 arg1 = reinterpret_cast< wxPoint * >(argp1);
5867 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5868 if (!SWIG_IsOK(ecode2)) {
5869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5870 }
5871 arg2 = static_cast< int >(val2);
5872 if (arg1) (arg1)->y = arg2;
5873
5874 resultobj = SWIG_Py_Void();
5875 return resultobj;
5876 fail:
5877 return NULL;
5878 }
5879
5880
5881 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5882 PyObject *resultobj = 0;
5883 wxPoint *arg1 = (wxPoint *) 0 ;
5884 int result;
5885 void *argp1 = 0 ;
5886 int res1 = 0 ;
5887 PyObject *swig_obj[1] ;
5888
5889 if (!args) SWIG_fail;
5890 swig_obj[0] = args;
5891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5892 if (!SWIG_IsOK(res1)) {
5893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5894 }
5895 arg1 = reinterpret_cast< wxPoint * >(argp1);
5896 result = (int) ((arg1)->y);
5897 resultobj = SWIG_From_int(static_cast< int >(result));
5898 return resultobj;
5899 fail:
5900 return NULL;
5901 }
5902
5903
5904 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5905 PyObject *resultobj = 0;
5906 int arg1 = (int) 0 ;
5907 int arg2 = (int) 0 ;
5908 wxPoint *result = 0 ;
5909 int val1 ;
5910 int ecode1 = 0 ;
5911 int val2 ;
5912 int ecode2 = 0 ;
5913 PyObject * obj0 = 0 ;
5914 PyObject * obj1 = 0 ;
5915 char * kwnames[] = {
5916 (char *) "x",(char *) "y", NULL
5917 };
5918
5919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5920 if (obj0) {
5921 ecode1 = SWIG_AsVal_int(obj0, &val1);
5922 if (!SWIG_IsOK(ecode1)) {
5923 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5924 }
5925 arg1 = static_cast< int >(val1);
5926 }
5927 if (obj1) {
5928 ecode2 = SWIG_AsVal_int(obj1, &val2);
5929 if (!SWIG_IsOK(ecode2)) {
5930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5931 }
5932 arg2 = static_cast< int >(val2);
5933 }
5934 {
5935 result = (wxPoint *)new wxPoint(arg1,arg2);
5936 if (PyErr_Occurred()) SWIG_fail;
5937 }
5938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5939 return resultobj;
5940 fail:
5941 return NULL;
5942 }
5943
5944
5945 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5946 PyObject *resultobj = 0;
5947 wxPoint *arg1 = (wxPoint *) 0 ;
5948 void *argp1 = 0 ;
5949 int res1 = 0 ;
5950 PyObject *swig_obj[1] ;
5951
5952 if (!args) SWIG_fail;
5953 swig_obj[0] = args;
5954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5955 if (!SWIG_IsOK(res1)) {
5956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5957 }
5958 arg1 = reinterpret_cast< wxPoint * >(argp1);
5959 {
5960 delete arg1;
5961
5962 if (PyErr_Occurred()) SWIG_fail;
5963 }
5964 resultobj = SWIG_Py_Void();
5965 return resultobj;
5966 fail:
5967 return NULL;
5968 }
5969
5970
5971 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5972 PyObject *resultobj = 0;
5973 wxPoint *arg1 = (wxPoint *) 0 ;
5974 PyObject *arg2 = (PyObject *) 0 ;
5975 bool result;
5976 void *argp1 = 0 ;
5977 int res1 = 0 ;
5978 PyObject * obj0 = 0 ;
5979 PyObject * obj1 = 0 ;
5980 char * kwnames[] = {
5981 (char *) "self",(char *) "other", NULL
5982 };
5983
5984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5986 if (!SWIG_IsOK(res1)) {
5987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5988 }
5989 arg1 = reinterpret_cast< wxPoint * >(argp1);
5990 arg2 = obj1;
5991 {
5992 result = (bool)wxPoint___eq__(arg1,arg2);
5993 if (PyErr_Occurred()) SWIG_fail;
5994 }
5995 {
5996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5997 }
5998 return resultobj;
5999 fail:
6000 return NULL;
6001 }
6002
6003
6004 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6005 PyObject *resultobj = 0;
6006 wxPoint *arg1 = (wxPoint *) 0 ;
6007 PyObject *arg2 = (PyObject *) 0 ;
6008 bool result;
6009 void *argp1 = 0 ;
6010 int res1 = 0 ;
6011 PyObject * obj0 = 0 ;
6012 PyObject * obj1 = 0 ;
6013 char * kwnames[] = {
6014 (char *) "self",(char *) "other", NULL
6015 };
6016
6017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
6018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6019 if (!SWIG_IsOK(res1)) {
6020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
6021 }
6022 arg1 = reinterpret_cast< wxPoint * >(argp1);
6023 arg2 = obj1;
6024 {
6025 result = (bool)wxPoint___ne__(arg1,arg2);
6026 if (PyErr_Occurred()) SWIG_fail;
6027 }
6028 {
6029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6030 }
6031 return resultobj;
6032 fail:
6033 return NULL;
6034 }
6035
6036
6037 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6038 PyObject *resultobj = 0;
6039 wxPoint *arg1 = (wxPoint *) 0 ;
6040 wxPoint *arg2 = 0 ;
6041 wxPoint result;
6042 void *argp1 = 0 ;
6043 int res1 = 0 ;
6044 wxPoint temp2 ;
6045 PyObject * obj0 = 0 ;
6046 PyObject * obj1 = 0 ;
6047 char * kwnames[] = {
6048 (char *) "self",(char *) "pt", NULL
6049 };
6050
6051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
6052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6053 if (!SWIG_IsOK(res1)) {
6054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
6055 }
6056 arg1 = reinterpret_cast< wxPoint * >(argp1);
6057 {
6058 arg2 = &temp2;
6059 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6060 }
6061 {
6062 result = (arg1)->operator +((wxPoint const &)*arg2);
6063 if (PyErr_Occurred()) SWIG_fail;
6064 }
6065 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6066 return resultobj;
6067 fail:
6068 return NULL;
6069 }
6070
6071
6072 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6073 PyObject *resultobj = 0;
6074 wxPoint *arg1 = (wxPoint *) 0 ;
6075 wxPoint *arg2 = 0 ;
6076 wxPoint result;
6077 void *argp1 = 0 ;
6078 int res1 = 0 ;
6079 wxPoint temp2 ;
6080 PyObject * obj0 = 0 ;
6081 PyObject * obj1 = 0 ;
6082 char * kwnames[] = {
6083 (char *) "self",(char *) "pt", NULL
6084 };
6085
6086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6088 if (!SWIG_IsOK(res1)) {
6089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6090 }
6091 arg1 = reinterpret_cast< wxPoint * >(argp1);
6092 {
6093 arg2 = &temp2;
6094 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6095 }
6096 {
6097 result = (arg1)->operator -((wxPoint const &)*arg2);
6098 if (PyErr_Occurred()) SWIG_fail;
6099 }
6100 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6101 return resultobj;
6102 fail:
6103 return NULL;
6104 }
6105
6106
6107 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6108 PyObject *resultobj = 0;
6109 wxPoint *arg1 = (wxPoint *) 0 ;
6110 wxPoint *arg2 = 0 ;
6111 wxPoint *result = 0 ;
6112 void *argp1 = 0 ;
6113 int res1 = 0 ;
6114 wxPoint temp2 ;
6115 PyObject * obj0 = 0 ;
6116 PyObject * obj1 = 0 ;
6117 char * kwnames[] = {
6118 (char *) "self",(char *) "pt", NULL
6119 };
6120
6121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6123 if (!SWIG_IsOK(res1)) {
6124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6125 }
6126 arg1 = reinterpret_cast< wxPoint * >(argp1);
6127 {
6128 arg2 = &temp2;
6129 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6130 }
6131 {
6132 {
6133 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6134 result = (wxPoint *) &_result_ref;
6135 }
6136 if (PyErr_Occurred()) SWIG_fail;
6137 }
6138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6139 return resultobj;
6140 fail:
6141 return NULL;
6142 }
6143
6144
6145 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6146 PyObject *resultobj = 0;
6147 wxPoint *arg1 = (wxPoint *) 0 ;
6148 wxPoint *arg2 = 0 ;
6149 wxPoint *result = 0 ;
6150 void *argp1 = 0 ;
6151 int res1 = 0 ;
6152 wxPoint temp2 ;
6153 PyObject * obj0 = 0 ;
6154 PyObject * obj1 = 0 ;
6155 char * kwnames[] = {
6156 (char *) "self",(char *) "pt", NULL
6157 };
6158
6159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6161 if (!SWIG_IsOK(res1)) {
6162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6163 }
6164 arg1 = reinterpret_cast< wxPoint * >(argp1);
6165 {
6166 arg2 = &temp2;
6167 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6168 }
6169 {
6170 {
6171 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6172 result = (wxPoint *) &_result_ref;
6173 }
6174 if (PyErr_Occurred()) SWIG_fail;
6175 }
6176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6177 return resultobj;
6178 fail:
6179 return NULL;
6180 }
6181
6182
6183 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6184 PyObject *resultobj = 0;
6185 wxPoint *arg1 = (wxPoint *) 0 ;
6186 long arg2 ;
6187 long arg3 ;
6188 void *argp1 = 0 ;
6189 int res1 = 0 ;
6190 long val2 ;
6191 int ecode2 = 0 ;
6192 long val3 ;
6193 int ecode3 = 0 ;
6194 PyObject * obj0 = 0 ;
6195 PyObject * obj1 = 0 ;
6196 PyObject * obj2 = 0 ;
6197 char * kwnames[] = {
6198 (char *) "self",(char *) "x",(char *) "y", NULL
6199 };
6200
6201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6203 if (!SWIG_IsOK(res1)) {
6204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6205 }
6206 arg1 = reinterpret_cast< wxPoint * >(argp1);
6207 ecode2 = SWIG_AsVal_long(obj1, &val2);
6208 if (!SWIG_IsOK(ecode2)) {
6209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6210 }
6211 arg2 = static_cast< long >(val2);
6212 ecode3 = SWIG_AsVal_long(obj2, &val3);
6213 if (!SWIG_IsOK(ecode3)) {
6214 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6215 }
6216 arg3 = static_cast< long >(val3);
6217 {
6218 wxPoint_Set(arg1,arg2,arg3);
6219 if (PyErr_Occurred()) SWIG_fail;
6220 }
6221 resultobj = SWIG_Py_Void();
6222 return resultobj;
6223 fail:
6224 return NULL;
6225 }
6226
6227
6228 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6229 PyObject *resultobj = 0;
6230 wxPoint *arg1 = (wxPoint *) 0 ;
6231 PyObject *result = 0 ;
6232 void *argp1 = 0 ;
6233 int res1 = 0 ;
6234 PyObject *swig_obj[1] ;
6235
6236 if (!args) SWIG_fail;
6237 swig_obj[0] = args;
6238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6239 if (!SWIG_IsOK(res1)) {
6240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6241 }
6242 arg1 = reinterpret_cast< wxPoint * >(argp1);
6243 {
6244 result = (PyObject *)wxPoint_Get(arg1);
6245 if (PyErr_Occurred()) SWIG_fail;
6246 }
6247 resultobj = result;
6248 return resultobj;
6249 fail:
6250 return NULL;
6251 }
6252
6253
6254 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6255 PyObject *obj;
6256 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6257 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6258 return SWIG_Py_Void();
6259 }
6260
6261 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6262 return SWIG_Python_InitShadowInstance(args);
6263 }
6264
6265 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6266 PyObject *resultobj = 0;
6267 int arg1 = (int) 0 ;
6268 int arg2 = (int) 0 ;
6269 int arg3 = (int) 0 ;
6270 int arg4 = (int) 0 ;
6271 wxRect *result = 0 ;
6272 int val1 ;
6273 int ecode1 = 0 ;
6274 int val2 ;
6275 int ecode2 = 0 ;
6276 int val3 ;
6277 int ecode3 = 0 ;
6278 int val4 ;
6279 int ecode4 = 0 ;
6280 PyObject * obj0 = 0 ;
6281 PyObject * obj1 = 0 ;
6282 PyObject * obj2 = 0 ;
6283 PyObject * obj3 = 0 ;
6284 char * kwnames[] = {
6285 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6286 };
6287
6288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6289 if (obj0) {
6290 ecode1 = SWIG_AsVal_int(obj0, &val1);
6291 if (!SWIG_IsOK(ecode1)) {
6292 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6293 }
6294 arg1 = static_cast< int >(val1);
6295 }
6296 if (obj1) {
6297 ecode2 = SWIG_AsVal_int(obj1, &val2);
6298 if (!SWIG_IsOK(ecode2)) {
6299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6300 }
6301 arg2 = static_cast< int >(val2);
6302 }
6303 if (obj2) {
6304 ecode3 = SWIG_AsVal_int(obj2, &val3);
6305 if (!SWIG_IsOK(ecode3)) {
6306 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6307 }
6308 arg3 = static_cast< int >(val3);
6309 }
6310 if (obj3) {
6311 ecode4 = SWIG_AsVal_int(obj3, &val4);
6312 if (!SWIG_IsOK(ecode4)) {
6313 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6314 }
6315 arg4 = static_cast< int >(val4);
6316 }
6317 {
6318 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6319 if (PyErr_Occurred()) SWIG_fail;
6320 }
6321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6322 return resultobj;
6323 fail:
6324 return NULL;
6325 }
6326
6327
6328 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6329 PyObject *resultobj = 0;
6330 wxPoint *arg1 = 0 ;
6331 wxPoint *arg2 = 0 ;
6332 wxRect *result = 0 ;
6333 wxPoint temp1 ;
6334 wxPoint temp2 ;
6335 PyObject * obj0 = 0 ;
6336 PyObject * obj1 = 0 ;
6337 char * kwnames[] = {
6338 (char *) "topLeft",(char *) "bottomRight", NULL
6339 };
6340
6341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6342 {
6343 arg1 = &temp1;
6344 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6345 }
6346 {
6347 arg2 = &temp2;
6348 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6349 }
6350 {
6351 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6352 if (PyErr_Occurred()) SWIG_fail;
6353 }
6354 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6355 return resultobj;
6356 fail:
6357 return NULL;
6358 }
6359
6360
6361 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6362 PyObject *resultobj = 0;
6363 wxPoint *arg1 = 0 ;
6364 wxSize *arg2 = 0 ;
6365 wxRect *result = 0 ;
6366 wxPoint temp1 ;
6367 wxSize temp2 ;
6368 PyObject * obj0 = 0 ;
6369 PyObject * obj1 = 0 ;
6370 char * kwnames[] = {
6371 (char *) "pos",(char *) "size", NULL
6372 };
6373
6374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6375 {
6376 arg1 = &temp1;
6377 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6378 }
6379 {
6380 arg2 = &temp2;
6381 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6382 }
6383 {
6384 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6385 if (PyErr_Occurred()) SWIG_fail;
6386 }
6387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6388 return resultobj;
6389 fail:
6390 return NULL;
6391 }
6392
6393
6394 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6395 PyObject *resultobj = 0;
6396 wxSize *arg1 = 0 ;
6397 wxRect *result = 0 ;
6398 wxSize temp1 ;
6399 PyObject * obj0 = 0 ;
6400 char * kwnames[] = {
6401 (char *) "size", NULL
6402 };
6403
6404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6405 {
6406 arg1 = &temp1;
6407 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6408 }
6409 {
6410 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6411 if (PyErr_Occurred()) SWIG_fail;
6412 }
6413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6414 return resultobj;
6415 fail:
6416 return NULL;
6417 }
6418
6419
6420 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6421 PyObject *resultobj = 0;
6422 wxRect *arg1 = (wxRect *) 0 ;
6423 void *argp1 = 0 ;
6424 int res1 = 0 ;
6425 PyObject *swig_obj[1] ;
6426
6427 if (!args) SWIG_fail;
6428 swig_obj[0] = args;
6429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6430 if (!SWIG_IsOK(res1)) {
6431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6432 }
6433 arg1 = reinterpret_cast< wxRect * >(argp1);
6434 {
6435 delete arg1;
6436
6437 if (PyErr_Occurred()) SWIG_fail;
6438 }
6439 resultobj = SWIG_Py_Void();
6440 return resultobj;
6441 fail:
6442 return NULL;
6443 }
6444
6445
6446 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6447 PyObject *resultobj = 0;
6448 wxRect *arg1 = (wxRect *) 0 ;
6449 int result;
6450 void *argp1 = 0 ;
6451 int res1 = 0 ;
6452 PyObject *swig_obj[1] ;
6453
6454 if (!args) SWIG_fail;
6455 swig_obj[0] = args;
6456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6457 if (!SWIG_IsOK(res1)) {
6458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6459 }
6460 arg1 = reinterpret_cast< wxRect * >(argp1);
6461 {
6462 result = (int)((wxRect const *)arg1)->GetX();
6463 if (PyErr_Occurred()) SWIG_fail;
6464 }
6465 resultobj = SWIG_From_int(static_cast< int >(result));
6466 return resultobj;
6467 fail:
6468 return NULL;
6469 }
6470
6471
6472 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6473 PyObject *resultobj = 0;
6474 wxRect *arg1 = (wxRect *) 0 ;
6475 int arg2 ;
6476 void *argp1 = 0 ;
6477 int res1 = 0 ;
6478 int val2 ;
6479 int ecode2 = 0 ;
6480 PyObject * obj0 = 0 ;
6481 PyObject * obj1 = 0 ;
6482 char * kwnames[] = {
6483 (char *) "self",(char *) "x", NULL
6484 };
6485
6486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6488 if (!SWIG_IsOK(res1)) {
6489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6490 }
6491 arg1 = reinterpret_cast< wxRect * >(argp1);
6492 ecode2 = SWIG_AsVal_int(obj1, &val2);
6493 if (!SWIG_IsOK(ecode2)) {
6494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6495 }
6496 arg2 = static_cast< int >(val2);
6497 {
6498 (arg1)->SetX(arg2);
6499 if (PyErr_Occurred()) SWIG_fail;
6500 }
6501 resultobj = SWIG_Py_Void();
6502 return resultobj;
6503 fail:
6504 return NULL;
6505 }
6506
6507
6508 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6509 PyObject *resultobj = 0;
6510 wxRect *arg1 = (wxRect *) 0 ;
6511 int result;
6512 void *argp1 = 0 ;
6513 int res1 = 0 ;
6514 PyObject *swig_obj[1] ;
6515
6516 if (!args) SWIG_fail;
6517 swig_obj[0] = args;
6518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6519 if (!SWIG_IsOK(res1)) {
6520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6521 }
6522 arg1 = reinterpret_cast< wxRect * >(argp1);
6523 {
6524 result = (int)(arg1)->GetY();
6525 if (PyErr_Occurred()) SWIG_fail;
6526 }
6527 resultobj = SWIG_From_int(static_cast< int >(result));
6528 return resultobj;
6529 fail:
6530 return NULL;
6531 }
6532
6533
6534 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6535 PyObject *resultobj = 0;
6536 wxRect *arg1 = (wxRect *) 0 ;
6537 int arg2 ;
6538 void *argp1 = 0 ;
6539 int res1 = 0 ;
6540 int val2 ;
6541 int ecode2 = 0 ;
6542 PyObject * obj0 = 0 ;
6543 PyObject * obj1 = 0 ;
6544 char * kwnames[] = {
6545 (char *) "self",(char *) "y", NULL
6546 };
6547
6548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6550 if (!SWIG_IsOK(res1)) {
6551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6552 }
6553 arg1 = reinterpret_cast< wxRect * >(argp1);
6554 ecode2 = SWIG_AsVal_int(obj1, &val2);
6555 if (!SWIG_IsOK(ecode2)) {
6556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6557 }
6558 arg2 = static_cast< int >(val2);
6559 {
6560 (arg1)->SetY(arg2);
6561 if (PyErr_Occurred()) SWIG_fail;
6562 }
6563 resultobj = SWIG_Py_Void();
6564 return resultobj;
6565 fail:
6566 return NULL;
6567 }
6568
6569
6570 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6571 PyObject *resultobj = 0;
6572 wxRect *arg1 = (wxRect *) 0 ;
6573 int result;
6574 void *argp1 = 0 ;
6575 int res1 = 0 ;
6576 PyObject *swig_obj[1] ;
6577
6578 if (!args) SWIG_fail;
6579 swig_obj[0] = args;
6580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6581 if (!SWIG_IsOK(res1)) {
6582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6583 }
6584 arg1 = reinterpret_cast< wxRect * >(argp1);
6585 {
6586 result = (int)((wxRect const *)arg1)->GetWidth();
6587 if (PyErr_Occurred()) SWIG_fail;
6588 }
6589 resultobj = SWIG_From_int(static_cast< int >(result));
6590 return resultobj;
6591 fail:
6592 return NULL;
6593 }
6594
6595
6596 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6597 PyObject *resultobj = 0;
6598 wxRect *arg1 = (wxRect *) 0 ;
6599 int arg2 ;
6600 void *argp1 = 0 ;
6601 int res1 = 0 ;
6602 int val2 ;
6603 int ecode2 = 0 ;
6604 PyObject * obj0 = 0 ;
6605 PyObject * obj1 = 0 ;
6606 char * kwnames[] = {
6607 (char *) "self",(char *) "w", NULL
6608 };
6609
6610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6612 if (!SWIG_IsOK(res1)) {
6613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6614 }
6615 arg1 = reinterpret_cast< wxRect * >(argp1);
6616 ecode2 = SWIG_AsVal_int(obj1, &val2);
6617 if (!SWIG_IsOK(ecode2)) {
6618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6619 }
6620 arg2 = static_cast< int >(val2);
6621 {
6622 (arg1)->SetWidth(arg2);
6623 if (PyErr_Occurred()) SWIG_fail;
6624 }
6625 resultobj = SWIG_Py_Void();
6626 return resultobj;
6627 fail:
6628 return NULL;
6629 }
6630
6631
6632 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6633 PyObject *resultobj = 0;
6634 wxRect *arg1 = (wxRect *) 0 ;
6635 int result;
6636 void *argp1 = 0 ;
6637 int res1 = 0 ;
6638 PyObject *swig_obj[1] ;
6639
6640 if (!args) SWIG_fail;
6641 swig_obj[0] = args;
6642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6643 if (!SWIG_IsOK(res1)) {
6644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6645 }
6646 arg1 = reinterpret_cast< wxRect * >(argp1);
6647 {
6648 result = (int)((wxRect const *)arg1)->GetHeight();
6649 if (PyErr_Occurred()) SWIG_fail;
6650 }
6651 resultobj = SWIG_From_int(static_cast< int >(result));
6652 return resultobj;
6653 fail:
6654 return NULL;
6655 }
6656
6657
6658 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6659 PyObject *resultobj = 0;
6660 wxRect *arg1 = (wxRect *) 0 ;
6661 int arg2 ;
6662 void *argp1 = 0 ;
6663 int res1 = 0 ;
6664 int val2 ;
6665 int ecode2 = 0 ;
6666 PyObject * obj0 = 0 ;
6667 PyObject * obj1 = 0 ;
6668 char * kwnames[] = {
6669 (char *) "self",(char *) "h", NULL
6670 };
6671
6672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6674 if (!SWIG_IsOK(res1)) {
6675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6676 }
6677 arg1 = reinterpret_cast< wxRect * >(argp1);
6678 ecode2 = SWIG_AsVal_int(obj1, &val2);
6679 if (!SWIG_IsOK(ecode2)) {
6680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6681 }
6682 arg2 = static_cast< int >(val2);
6683 {
6684 (arg1)->SetHeight(arg2);
6685 if (PyErr_Occurred()) SWIG_fail;
6686 }
6687 resultobj = SWIG_Py_Void();
6688 return resultobj;
6689 fail:
6690 return NULL;
6691 }
6692
6693
6694 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6695 PyObject *resultobj = 0;
6696 wxRect *arg1 = (wxRect *) 0 ;
6697 wxPoint result;
6698 void *argp1 = 0 ;
6699 int res1 = 0 ;
6700 PyObject *swig_obj[1] ;
6701
6702 if (!args) SWIG_fail;
6703 swig_obj[0] = args;
6704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6705 if (!SWIG_IsOK(res1)) {
6706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6707 }
6708 arg1 = reinterpret_cast< wxRect * >(argp1);
6709 {
6710 result = ((wxRect const *)arg1)->GetPosition();
6711 if (PyErr_Occurred()) SWIG_fail;
6712 }
6713 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6714 return resultobj;
6715 fail:
6716 return NULL;
6717 }
6718
6719
6720 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6721 PyObject *resultobj = 0;
6722 wxRect *arg1 = (wxRect *) 0 ;
6723 wxPoint *arg2 = 0 ;
6724 void *argp1 = 0 ;
6725 int res1 = 0 ;
6726 wxPoint temp2 ;
6727 PyObject * obj0 = 0 ;
6728 PyObject * obj1 = 0 ;
6729 char * kwnames[] = {
6730 (char *) "self",(char *) "p", NULL
6731 };
6732
6733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6735 if (!SWIG_IsOK(res1)) {
6736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6737 }
6738 arg1 = reinterpret_cast< wxRect * >(argp1);
6739 {
6740 arg2 = &temp2;
6741 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6742 }
6743 {
6744 (arg1)->SetPosition((wxPoint const &)*arg2);
6745 if (PyErr_Occurred()) SWIG_fail;
6746 }
6747 resultobj = SWIG_Py_Void();
6748 return resultobj;
6749 fail:
6750 return NULL;
6751 }
6752
6753
6754 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6755 PyObject *resultobj = 0;
6756 wxRect *arg1 = (wxRect *) 0 ;
6757 wxSize result;
6758 void *argp1 = 0 ;
6759 int res1 = 0 ;
6760 PyObject *swig_obj[1] ;
6761
6762 if (!args) SWIG_fail;
6763 swig_obj[0] = args;
6764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6765 if (!SWIG_IsOK(res1)) {
6766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6767 }
6768 arg1 = reinterpret_cast< wxRect * >(argp1);
6769 {
6770 result = ((wxRect const *)arg1)->GetSize();
6771 if (PyErr_Occurred()) SWIG_fail;
6772 }
6773 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6774 return resultobj;
6775 fail:
6776 return NULL;
6777 }
6778
6779
6780 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6781 PyObject *resultobj = 0;
6782 wxRect *arg1 = (wxRect *) 0 ;
6783 wxSize *arg2 = 0 ;
6784 void *argp1 = 0 ;
6785 int res1 = 0 ;
6786 wxSize temp2 ;
6787 PyObject * obj0 = 0 ;
6788 PyObject * obj1 = 0 ;
6789 char * kwnames[] = {
6790 (char *) "self",(char *) "s", NULL
6791 };
6792
6793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6795 if (!SWIG_IsOK(res1)) {
6796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6797 }
6798 arg1 = reinterpret_cast< wxRect * >(argp1);
6799 {
6800 arg2 = &temp2;
6801 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6802 }
6803 {
6804 (arg1)->SetSize((wxSize const &)*arg2);
6805 if (PyErr_Occurred()) SWIG_fail;
6806 }
6807 resultobj = SWIG_Py_Void();
6808 return resultobj;
6809 fail:
6810 return NULL;
6811 }
6812
6813
6814 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6815 PyObject *resultobj = 0;
6816 wxRect *arg1 = (wxRect *) 0 ;
6817 bool result;
6818 void *argp1 = 0 ;
6819 int res1 = 0 ;
6820 PyObject *swig_obj[1] ;
6821
6822 if (!args) SWIG_fail;
6823 swig_obj[0] = args;
6824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6825 if (!SWIG_IsOK(res1)) {
6826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6827 }
6828 arg1 = reinterpret_cast< wxRect * >(argp1);
6829 {
6830 result = (bool)((wxRect const *)arg1)->IsEmpty();
6831 if (PyErr_Occurred()) SWIG_fail;
6832 }
6833 {
6834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6835 }
6836 return resultobj;
6837 fail:
6838 return NULL;
6839 }
6840
6841
6842 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6843 PyObject *resultobj = 0;
6844 wxRect *arg1 = (wxRect *) 0 ;
6845 wxPoint result;
6846 void *argp1 = 0 ;
6847 int res1 = 0 ;
6848 PyObject *swig_obj[1] ;
6849
6850 if (!args) SWIG_fail;
6851 swig_obj[0] = args;
6852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6853 if (!SWIG_IsOK(res1)) {
6854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6855 }
6856 arg1 = reinterpret_cast< wxRect * >(argp1);
6857 {
6858 result = ((wxRect const *)arg1)->GetTopLeft();
6859 if (PyErr_Occurred()) SWIG_fail;
6860 }
6861 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6862 return resultobj;
6863 fail:
6864 return NULL;
6865 }
6866
6867
6868 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6869 PyObject *resultobj = 0;
6870 wxRect *arg1 = (wxRect *) 0 ;
6871 wxPoint *arg2 = 0 ;
6872 void *argp1 = 0 ;
6873 int res1 = 0 ;
6874 wxPoint temp2 ;
6875 PyObject * obj0 = 0 ;
6876 PyObject * obj1 = 0 ;
6877 char * kwnames[] = {
6878 (char *) "self",(char *) "p", NULL
6879 };
6880
6881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6883 if (!SWIG_IsOK(res1)) {
6884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6885 }
6886 arg1 = reinterpret_cast< wxRect * >(argp1);
6887 {
6888 arg2 = &temp2;
6889 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6890 }
6891 {
6892 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6893 if (PyErr_Occurred()) SWIG_fail;
6894 }
6895 resultobj = SWIG_Py_Void();
6896 return resultobj;
6897 fail:
6898 return NULL;
6899 }
6900
6901
6902 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6903 PyObject *resultobj = 0;
6904 wxRect *arg1 = (wxRect *) 0 ;
6905 wxPoint result;
6906 void *argp1 = 0 ;
6907 int res1 = 0 ;
6908 PyObject *swig_obj[1] ;
6909
6910 if (!args) SWIG_fail;
6911 swig_obj[0] = args;
6912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6913 if (!SWIG_IsOK(res1)) {
6914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6915 }
6916 arg1 = reinterpret_cast< wxRect * >(argp1);
6917 {
6918 result = ((wxRect const *)arg1)->GetBottomRight();
6919 if (PyErr_Occurred()) SWIG_fail;
6920 }
6921 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6922 return resultobj;
6923 fail:
6924 return NULL;
6925 }
6926
6927
6928 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6929 PyObject *resultobj = 0;
6930 wxRect *arg1 = (wxRect *) 0 ;
6931 wxPoint *arg2 = 0 ;
6932 void *argp1 = 0 ;
6933 int res1 = 0 ;
6934 wxPoint temp2 ;
6935 PyObject * obj0 = 0 ;
6936 PyObject * obj1 = 0 ;
6937 char * kwnames[] = {
6938 (char *) "self",(char *) "p", NULL
6939 };
6940
6941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6943 if (!SWIG_IsOK(res1)) {
6944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6945 }
6946 arg1 = reinterpret_cast< wxRect * >(argp1);
6947 {
6948 arg2 = &temp2;
6949 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6950 }
6951 {
6952 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6953 if (PyErr_Occurred()) SWIG_fail;
6954 }
6955 resultobj = SWIG_Py_Void();
6956 return resultobj;
6957 fail:
6958 return NULL;
6959 }
6960
6961
6962 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6963 PyObject *resultobj = 0;
6964 wxRect *arg1 = (wxRect *) 0 ;
6965 wxPoint result;
6966 void *argp1 = 0 ;
6967 int res1 = 0 ;
6968 PyObject *swig_obj[1] ;
6969
6970 if (!args) SWIG_fail;
6971 swig_obj[0] = args;
6972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6973 if (!SWIG_IsOK(res1)) {
6974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6975 }
6976 arg1 = reinterpret_cast< wxRect * >(argp1);
6977 {
6978 result = ((wxRect const *)arg1)->GetTopRight();
6979 if (PyErr_Occurred()) SWIG_fail;
6980 }
6981 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6982 return resultobj;
6983 fail:
6984 return NULL;
6985 }
6986
6987
6988 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6989 PyObject *resultobj = 0;
6990 wxRect *arg1 = (wxRect *) 0 ;
6991 wxPoint *arg2 = 0 ;
6992 void *argp1 = 0 ;
6993 int res1 = 0 ;
6994 wxPoint temp2 ;
6995 PyObject * obj0 = 0 ;
6996 PyObject * obj1 = 0 ;
6997 char * kwnames[] = {
6998 (char *) "self",(char *) "p", NULL
6999 };
7000
7001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
7002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7003 if (!SWIG_IsOK(res1)) {
7004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
7005 }
7006 arg1 = reinterpret_cast< wxRect * >(argp1);
7007 {
7008 arg2 = &temp2;
7009 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7010 }
7011 {
7012 (arg1)->SetTopRight((wxPoint const &)*arg2);
7013 if (PyErr_Occurred()) SWIG_fail;
7014 }
7015 resultobj = SWIG_Py_Void();
7016 return resultobj;
7017 fail:
7018 return NULL;
7019 }
7020
7021
7022 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7023 PyObject *resultobj = 0;
7024 wxRect *arg1 = (wxRect *) 0 ;
7025 wxPoint result;
7026 void *argp1 = 0 ;
7027 int res1 = 0 ;
7028 PyObject *swig_obj[1] ;
7029
7030 if (!args) SWIG_fail;
7031 swig_obj[0] = args;
7032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7033 if (!SWIG_IsOK(res1)) {
7034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7035 }
7036 arg1 = reinterpret_cast< wxRect * >(argp1);
7037 {
7038 result = ((wxRect const *)arg1)->GetBottomLeft();
7039 if (PyErr_Occurred()) SWIG_fail;
7040 }
7041 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7042 return resultobj;
7043 fail:
7044 return NULL;
7045 }
7046
7047
7048 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7049 PyObject *resultobj = 0;
7050 wxRect *arg1 = (wxRect *) 0 ;
7051 wxPoint *arg2 = 0 ;
7052 void *argp1 = 0 ;
7053 int res1 = 0 ;
7054 wxPoint temp2 ;
7055 PyObject * obj0 = 0 ;
7056 PyObject * obj1 = 0 ;
7057 char * kwnames[] = {
7058 (char *) "self",(char *) "p", NULL
7059 };
7060
7061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7063 if (!SWIG_IsOK(res1)) {
7064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7065 }
7066 arg1 = reinterpret_cast< wxRect * >(argp1);
7067 {
7068 arg2 = &temp2;
7069 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7070 }
7071 {
7072 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7073 if (PyErr_Occurred()) SWIG_fail;
7074 }
7075 resultobj = SWIG_Py_Void();
7076 return resultobj;
7077 fail:
7078 return NULL;
7079 }
7080
7081
7082 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7083 PyObject *resultobj = 0;
7084 wxRect *arg1 = (wxRect *) 0 ;
7085 int result;
7086 void *argp1 = 0 ;
7087 int res1 = 0 ;
7088 PyObject *swig_obj[1] ;
7089
7090 if (!args) SWIG_fail;
7091 swig_obj[0] = args;
7092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7093 if (!SWIG_IsOK(res1)) {
7094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7095 }
7096 arg1 = reinterpret_cast< wxRect * >(argp1);
7097 {
7098 result = (int)((wxRect const *)arg1)->GetLeft();
7099 if (PyErr_Occurred()) SWIG_fail;
7100 }
7101 resultobj = SWIG_From_int(static_cast< int >(result));
7102 return resultobj;
7103 fail:
7104 return NULL;
7105 }
7106
7107
7108 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7109 PyObject *resultobj = 0;
7110 wxRect *arg1 = (wxRect *) 0 ;
7111 int result;
7112 void *argp1 = 0 ;
7113 int res1 = 0 ;
7114 PyObject *swig_obj[1] ;
7115
7116 if (!args) SWIG_fail;
7117 swig_obj[0] = args;
7118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7119 if (!SWIG_IsOK(res1)) {
7120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7121 }
7122 arg1 = reinterpret_cast< wxRect * >(argp1);
7123 {
7124 result = (int)((wxRect const *)arg1)->GetTop();
7125 if (PyErr_Occurred()) SWIG_fail;
7126 }
7127 resultobj = SWIG_From_int(static_cast< int >(result));
7128 return resultobj;
7129 fail:
7130 return NULL;
7131 }
7132
7133
7134 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7135 PyObject *resultobj = 0;
7136 wxRect *arg1 = (wxRect *) 0 ;
7137 int result;
7138 void *argp1 = 0 ;
7139 int res1 = 0 ;
7140 PyObject *swig_obj[1] ;
7141
7142 if (!args) SWIG_fail;
7143 swig_obj[0] = args;
7144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7145 if (!SWIG_IsOK(res1)) {
7146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7147 }
7148 arg1 = reinterpret_cast< wxRect * >(argp1);
7149 {
7150 result = (int)((wxRect const *)arg1)->GetBottom();
7151 if (PyErr_Occurred()) SWIG_fail;
7152 }
7153 resultobj = SWIG_From_int(static_cast< int >(result));
7154 return resultobj;
7155 fail:
7156 return NULL;
7157 }
7158
7159
7160 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7161 PyObject *resultobj = 0;
7162 wxRect *arg1 = (wxRect *) 0 ;
7163 int result;
7164 void *argp1 = 0 ;
7165 int res1 = 0 ;
7166 PyObject *swig_obj[1] ;
7167
7168 if (!args) SWIG_fail;
7169 swig_obj[0] = args;
7170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7171 if (!SWIG_IsOK(res1)) {
7172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7173 }
7174 arg1 = reinterpret_cast< wxRect * >(argp1);
7175 {
7176 result = (int)((wxRect const *)arg1)->GetRight();
7177 if (PyErr_Occurred()) SWIG_fail;
7178 }
7179 resultobj = SWIG_From_int(static_cast< int >(result));
7180 return resultobj;
7181 fail:
7182 return NULL;
7183 }
7184
7185
7186 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7187 PyObject *resultobj = 0;
7188 wxRect *arg1 = (wxRect *) 0 ;
7189 int arg2 ;
7190 void *argp1 = 0 ;
7191 int res1 = 0 ;
7192 int val2 ;
7193 int ecode2 = 0 ;
7194 PyObject * obj0 = 0 ;
7195 PyObject * obj1 = 0 ;
7196 char * kwnames[] = {
7197 (char *) "self",(char *) "left", NULL
7198 };
7199
7200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7202 if (!SWIG_IsOK(res1)) {
7203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7204 }
7205 arg1 = reinterpret_cast< wxRect * >(argp1);
7206 ecode2 = SWIG_AsVal_int(obj1, &val2);
7207 if (!SWIG_IsOK(ecode2)) {
7208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7209 }
7210 arg2 = static_cast< int >(val2);
7211 {
7212 (arg1)->SetLeft(arg2);
7213 if (PyErr_Occurred()) SWIG_fail;
7214 }
7215 resultobj = SWIG_Py_Void();
7216 return resultobj;
7217 fail:
7218 return NULL;
7219 }
7220
7221
7222 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7223 PyObject *resultobj = 0;
7224 wxRect *arg1 = (wxRect *) 0 ;
7225 int arg2 ;
7226 void *argp1 = 0 ;
7227 int res1 = 0 ;
7228 int val2 ;
7229 int ecode2 = 0 ;
7230 PyObject * obj0 = 0 ;
7231 PyObject * obj1 = 0 ;
7232 char * kwnames[] = {
7233 (char *) "self",(char *) "right", NULL
7234 };
7235
7236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7238 if (!SWIG_IsOK(res1)) {
7239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7240 }
7241 arg1 = reinterpret_cast< wxRect * >(argp1);
7242 ecode2 = SWIG_AsVal_int(obj1, &val2);
7243 if (!SWIG_IsOK(ecode2)) {
7244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7245 }
7246 arg2 = static_cast< int >(val2);
7247 {
7248 (arg1)->SetRight(arg2);
7249 if (PyErr_Occurred()) SWIG_fail;
7250 }
7251 resultobj = SWIG_Py_Void();
7252 return resultobj;
7253 fail:
7254 return NULL;
7255 }
7256
7257
7258 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7259 PyObject *resultobj = 0;
7260 wxRect *arg1 = (wxRect *) 0 ;
7261 int arg2 ;
7262 void *argp1 = 0 ;
7263 int res1 = 0 ;
7264 int val2 ;
7265 int ecode2 = 0 ;
7266 PyObject * obj0 = 0 ;
7267 PyObject * obj1 = 0 ;
7268 char * kwnames[] = {
7269 (char *) "self",(char *) "top", NULL
7270 };
7271
7272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7274 if (!SWIG_IsOK(res1)) {
7275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7276 }
7277 arg1 = reinterpret_cast< wxRect * >(argp1);
7278 ecode2 = SWIG_AsVal_int(obj1, &val2);
7279 if (!SWIG_IsOK(ecode2)) {
7280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7281 }
7282 arg2 = static_cast< int >(val2);
7283 {
7284 (arg1)->SetTop(arg2);
7285 if (PyErr_Occurred()) SWIG_fail;
7286 }
7287 resultobj = SWIG_Py_Void();
7288 return resultobj;
7289 fail:
7290 return NULL;
7291 }
7292
7293
7294 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7295 PyObject *resultobj = 0;
7296 wxRect *arg1 = (wxRect *) 0 ;
7297 int arg2 ;
7298 void *argp1 = 0 ;
7299 int res1 = 0 ;
7300 int val2 ;
7301 int ecode2 = 0 ;
7302 PyObject * obj0 = 0 ;
7303 PyObject * obj1 = 0 ;
7304 char * kwnames[] = {
7305 (char *) "self",(char *) "bottom", NULL
7306 };
7307
7308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7310 if (!SWIG_IsOK(res1)) {
7311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7312 }
7313 arg1 = reinterpret_cast< wxRect * >(argp1);
7314 ecode2 = SWIG_AsVal_int(obj1, &val2);
7315 if (!SWIG_IsOK(ecode2)) {
7316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7317 }
7318 arg2 = static_cast< int >(val2);
7319 {
7320 (arg1)->SetBottom(arg2);
7321 if (PyErr_Occurred()) SWIG_fail;
7322 }
7323 resultobj = SWIG_Py_Void();
7324 return resultobj;
7325 fail:
7326 return NULL;
7327 }
7328
7329
7330 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7331 PyObject *resultobj = 0;
7332 wxRect *arg1 = (wxRect *) 0 ;
7333 int arg2 ;
7334 int arg3 ;
7335 wxRect result;
7336 void *argp1 = 0 ;
7337 int res1 = 0 ;
7338 int val2 ;
7339 int ecode2 = 0 ;
7340 int val3 ;
7341 int ecode3 = 0 ;
7342 PyObject * obj0 = 0 ;
7343 PyObject * obj1 = 0 ;
7344 PyObject * obj2 = 0 ;
7345 char * kwnames[] = {
7346 (char *) "self",(char *) "dx",(char *) "dy", NULL
7347 };
7348
7349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7351 if (!SWIG_IsOK(res1)) {
7352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7353 }
7354 arg1 = reinterpret_cast< wxRect * >(argp1);
7355 ecode2 = SWIG_AsVal_int(obj1, &val2);
7356 if (!SWIG_IsOK(ecode2)) {
7357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7358 }
7359 arg2 = static_cast< int >(val2);
7360 ecode3 = SWIG_AsVal_int(obj2, &val3);
7361 if (!SWIG_IsOK(ecode3)) {
7362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7363 }
7364 arg3 = static_cast< int >(val3);
7365 {
7366 result = (arg1)->Inflate(arg2,arg3);
7367 if (PyErr_Occurred()) SWIG_fail;
7368 }
7369 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7370 return resultobj;
7371 fail:
7372 return NULL;
7373 }
7374
7375
7376 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7377 PyObject *resultobj = 0;
7378 wxRect *arg1 = (wxRect *) 0 ;
7379 int arg2 ;
7380 int arg3 ;
7381 wxRect *result = 0 ;
7382 void *argp1 = 0 ;
7383 int res1 = 0 ;
7384 int val2 ;
7385 int ecode2 = 0 ;
7386 int val3 ;
7387 int ecode3 = 0 ;
7388 PyObject * obj0 = 0 ;
7389 PyObject * obj1 = 0 ;
7390 PyObject * obj2 = 0 ;
7391 char * kwnames[] = {
7392 (char *) "self",(char *) "dx",(char *) "dy", NULL
7393 };
7394
7395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7397 if (!SWIG_IsOK(res1)) {
7398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7399 }
7400 arg1 = reinterpret_cast< wxRect * >(argp1);
7401 ecode2 = SWIG_AsVal_int(obj1, &val2);
7402 if (!SWIG_IsOK(ecode2)) {
7403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7404 }
7405 arg2 = static_cast< int >(val2);
7406 ecode3 = SWIG_AsVal_int(obj2, &val3);
7407 if (!SWIG_IsOK(ecode3)) {
7408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7409 }
7410 arg3 = static_cast< int >(val3);
7411 {
7412 {
7413 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7414 result = (wxRect *) &_result_ref;
7415 }
7416 if (PyErr_Occurred()) SWIG_fail;
7417 }
7418 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7419 return resultobj;
7420 fail:
7421 return NULL;
7422 }
7423
7424
7425 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7426 PyObject *resultobj = 0;
7427 wxRect *arg1 = (wxRect *) 0 ;
7428 int arg2 ;
7429 int arg3 ;
7430 void *argp1 = 0 ;
7431 int res1 = 0 ;
7432 int val2 ;
7433 int ecode2 = 0 ;
7434 int val3 ;
7435 int ecode3 = 0 ;
7436 PyObject * obj0 = 0 ;
7437 PyObject * obj1 = 0 ;
7438 PyObject * obj2 = 0 ;
7439 char * kwnames[] = {
7440 (char *) "self",(char *) "dx",(char *) "dy", NULL
7441 };
7442
7443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7445 if (!SWIG_IsOK(res1)) {
7446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7447 }
7448 arg1 = reinterpret_cast< wxRect * >(argp1);
7449 ecode2 = SWIG_AsVal_int(obj1, &val2);
7450 if (!SWIG_IsOK(ecode2)) {
7451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7452 }
7453 arg2 = static_cast< int >(val2);
7454 ecode3 = SWIG_AsVal_int(obj2, &val3);
7455 if (!SWIG_IsOK(ecode3)) {
7456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7457 }
7458 arg3 = static_cast< int >(val3);
7459 {
7460 (arg1)->Offset(arg2,arg3);
7461 if (PyErr_Occurred()) SWIG_fail;
7462 }
7463 resultobj = SWIG_Py_Void();
7464 return resultobj;
7465 fail:
7466 return NULL;
7467 }
7468
7469
7470 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7471 PyObject *resultobj = 0;
7472 wxRect *arg1 = (wxRect *) 0 ;
7473 wxPoint *arg2 = 0 ;
7474 void *argp1 = 0 ;
7475 int res1 = 0 ;
7476 wxPoint temp2 ;
7477 PyObject * obj0 = 0 ;
7478 PyObject * obj1 = 0 ;
7479 char * kwnames[] = {
7480 (char *) "self",(char *) "pt", NULL
7481 };
7482
7483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7485 if (!SWIG_IsOK(res1)) {
7486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7487 }
7488 arg1 = reinterpret_cast< wxRect * >(argp1);
7489 {
7490 arg2 = &temp2;
7491 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7492 }
7493 {
7494 (arg1)->Offset((wxPoint const &)*arg2);
7495 if (PyErr_Occurred()) SWIG_fail;
7496 }
7497 resultobj = SWIG_Py_Void();
7498 return resultobj;
7499 fail:
7500 return NULL;
7501 }
7502
7503
7504 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7505 PyObject *resultobj = 0;
7506 wxRect *arg1 = (wxRect *) 0 ;
7507 wxRect *arg2 = 0 ;
7508 wxRect result;
7509 void *argp1 = 0 ;
7510 int res1 = 0 ;
7511 wxRect temp2 ;
7512 PyObject * obj0 = 0 ;
7513 PyObject * obj1 = 0 ;
7514 char * kwnames[] = {
7515 (char *) "self",(char *) "rect", NULL
7516 };
7517
7518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7520 if (!SWIG_IsOK(res1)) {
7521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7522 }
7523 arg1 = reinterpret_cast< wxRect * >(argp1);
7524 {
7525 arg2 = &temp2;
7526 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7527 }
7528 {
7529 result = (arg1)->Intersect((wxRect const &)*arg2);
7530 if (PyErr_Occurred()) SWIG_fail;
7531 }
7532 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7533 return resultobj;
7534 fail:
7535 return NULL;
7536 }
7537
7538
7539 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7540 PyObject *resultobj = 0;
7541 wxRect *arg1 = (wxRect *) 0 ;
7542 wxRect *arg2 = 0 ;
7543 wxRect result;
7544 void *argp1 = 0 ;
7545 int res1 = 0 ;
7546 wxRect temp2 ;
7547 PyObject * obj0 = 0 ;
7548 PyObject * obj1 = 0 ;
7549 char * kwnames[] = {
7550 (char *) "self",(char *) "rect", NULL
7551 };
7552
7553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7555 if (!SWIG_IsOK(res1)) {
7556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7557 }
7558 arg1 = reinterpret_cast< wxRect * >(argp1);
7559 {
7560 arg2 = &temp2;
7561 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7562 }
7563 {
7564 result = (arg1)->Union((wxRect const &)*arg2);
7565 if (PyErr_Occurred()) SWIG_fail;
7566 }
7567 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7568 return resultobj;
7569 fail:
7570 return NULL;
7571 }
7572
7573
7574 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7575 PyObject *resultobj = 0;
7576 wxRect *arg1 = (wxRect *) 0 ;
7577 wxRect *arg2 = 0 ;
7578 wxRect result;
7579 void *argp1 = 0 ;
7580 int res1 = 0 ;
7581 wxRect temp2 ;
7582 PyObject * obj0 = 0 ;
7583 PyObject * obj1 = 0 ;
7584 char * kwnames[] = {
7585 (char *) "self",(char *) "rect", NULL
7586 };
7587
7588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7590 if (!SWIG_IsOK(res1)) {
7591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7592 }
7593 arg1 = reinterpret_cast< wxRect * >(argp1);
7594 {
7595 arg2 = &temp2;
7596 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7597 }
7598 {
7599 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7600 if (PyErr_Occurred()) SWIG_fail;
7601 }
7602 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7603 return resultobj;
7604 fail:
7605 return NULL;
7606 }
7607
7608
7609 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7610 PyObject *resultobj = 0;
7611 wxRect *arg1 = (wxRect *) 0 ;
7612 wxRect *arg2 = 0 ;
7613 wxRect *result = 0 ;
7614 void *argp1 = 0 ;
7615 int res1 = 0 ;
7616 wxRect temp2 ;
7617 PyObject * obj0 = 0 ;
7618 PyObject * obj1 = 0 ;
7619 char * kwnames[] = {
7620 (char *) "self",(char *) "rect", NULL
7621 };
7622
7623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7625 if (!SWIG_IsOK(res1)) {
7626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7627 }
7628 arg1 = reinterpret_cast< wxRect * >(argp1);
7629 {
7630 arg2 = &temp2;
7631 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7632 }
7633 {
7634 {
7635 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7636 result = (wxRect *) &_result_ref;
7637 }
7638 if (PyErr_Occurred()) SWIG_fail;
7639 }
7640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7641 return resultobj;
7642 fail:
7643 return NULL;
7644 }
7645
7646
7647 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7648 PyObject *resultobj = 0;
7649 wxRect *arg1 = (wxRect *) 0 ;
7650 PyObject *arg2 = (PyObject *) 0 ;
7651 bool result;
7652 void *argp1 = 0 ;
7653 int res1 = 0 ;
7654 PyObject * obj0 = 0 ;
7655 PyObject * obj1 = 0 ;
7656 char * kwnames[] = {
7657 (char *) "self",(char *) "other", NULL
7658 };
7659
7660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7662 if (!SWIG_IsOK(res1)) {
7663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7664 }
7665 arg1 = reinterpret_cast< wxRect * >(argp1);
7666 arg2 = obj1;
7667 {
7668 result = (bool)wxRect___eq__(arg1,arg2);
7669 if (PyErr_Occurred()) SWIG_fail;
7670 }
7671 {
7672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7673 }
7674 return resultobj;
7675 fail:
7676 return NULL;
7677 }
7678
7679
7680 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7681 PyObject *resultobj = 0;
7682 wxRect *arg1 = (wxRect *) 0 ;
7683 PyObject *arg2 = (PyObject *) 0 ;
7684 bool result;
7685 void *argp1 = 0 ;
7686 int res1 = 0 ;
7687 PyObject * obj0 = 0 ;
7688 PyObject * obj1 = 0 ;
7689 char * kwnames[] = {
7690 (char *) "self",(char *) "other", NULL
7691 };
7692
7693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7695 if (!SWIG_IsOK(res1)) {
7696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7697 }
7698 arg1 = reinterpret_cast< wxRect * >(argp1);
7699 arg2 = obj1;
7700 {
7701 result = (bool)wxRect___ne__(arg1,arg2);
7702 if (PyErr_Occurred()) SWIG_fail;
7703 }
7704 {
7705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7706 }
7707 return resultobj;
7708 fail:
7709 return NULL;
7710 }
7711
7712
7713 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7714 PyObject *resultobj = 0;
7715 wxRect *arg1 = (wxRect *) 0 ;
7716 int arg2 ;
7717 int arg3 ;
7718 bool result;
7719 void *argp1 = 0 ;
7720 int res1 = 0 ;
7721 int val2 ;
7722 int ecode2 = 0 ;
7723 int val3 ;
7724 int ecode3 = 0 ;
7725 PyObject * obj0 = 0 ;
7726 PyObject * obj1 = 0 ;
7727 PyObject * obj2 = 0 ;
7728 char * kwnames[] = {
7729 (char *) "self",(char *) "x",(char *) "y", NULL
7730 };
7731
7732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7734 if (!SWIG_IsOK(res1)) {
7735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7736 }
7737 arg1 = reinterpret_cast< wxRect * >(argp1);
7738 ecode2 = SWIG_AsVal_int(obj1, &val2);
7739 if (!SWIG_IsOK(ecode2)) {
7740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7741 }
7742 arg2 = static_cast< int >(val2);
7743 ecode3 = SWIG_AsVal_int(obj2, &val3);
7744 if (!SWIG_IsOK(ecode3)) {
7745 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7746 }
7747 arg3 = static_cast< int >(val3);
7748 {
7749 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7750 if (PyErr_Occurred()) SWIG_fail;
7751 }
7752 {
7753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7754 }
7755 return resultobj;
7756 fail:
7757 return NULL;
7758 }
7759
7760
7761 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7762 PyObject *resultobj = 0;
7763 wxRect *arg1 = (wxRect *) 0 ;
7764 wxPoint *arg2 = 0 ;
7765 bool result;
7766 void *argp1 = 0 ;
7767 int res1 = 0 ;
7768 wxPoint temp2 ;
7769 PyObject * obj0 = 0 ;
7770 PyObject * obj1 = 0 ;
7771 char * kwnames[] = {
7772 (char *) "self",(char *) "pt", NULL
7773 };
7774
7775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7777 if (!SWIG_IsOK(res1)) {
7778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7779 }
7780 arg1 = reinterpret_cast< wxRect * >(argp1);
7781 {
7782 arg2 = &temp2;
7783 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7784 }
7785 {
7786 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7787 if (PyErr_Occurred()) SWIG_fail;
7788 }
7789 {
7790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7791 }
7792 return resultobj;
7793 fail:
7794 return NULL;
7795 }
7796
7797
7798 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7799 PyObject *resultobj = 0;
7800 wxRect *arg1 = (wxRect *) 0 ;
7801 wxRect *arg2 = 0 ;
7802 bool result;
7803 void *argp1 = 0 ;
7804 int res1 = 0 ;
7805 wxRect temp2 ;
7806 PyObject * obj0 = 0 ;
7807 PyObject * obj1 = 0 ;
7808 char * kwnames[] = {
7809 (char *) "self",(char *) "rect", NULL
7810 };
7811
7812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7814 if (!SWIG_IsOK(res1)) {
7815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7816 }
7817 arg1 = reinterpret_cast< wxRect * >(argp1);
7818 {
7819 arg2 = &temp2;
7820 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7821 }
7822 {
7823 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7824 if (PyErr_Occurred()) SWIG_fail;
7825 }
7826 {
7827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7828 }
7829 return resultobj;
7830 fail:
7831 return NULL;
7832 }
7833
7834
7835 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7836 PyObject *resultobj = 0;
7837 wxRect *arg1 = (wxRect *) 0 ;
7838 wxRect *arg2 = 0 ;
7839 bool result;
7840 void *argp1 = 0 ;
7841 int res1 = 0 ;
7842 wxRect temp2 ;
7843 PyObject * obj0 = 0 ;
7844 PyObject * obj1 = 0 ;
7845 char * kwnames[] = {
7846 (char *) "self",(char *) "rect", NULL
7847 };
7848
7849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7851 if (!SWIG_IsOK(res1)) {
7852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7853 }
7854 arg1 = reinterpret_cast< wxRect * >(argp1);
7855 {
7856 arg2 = &temp2;
7857 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7858 }
7859 {
7860 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7861 if (PyErr_Occurred()) SWIG_fail;
7862 }
7863 {
7864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7865 }
7866 return resultobj;
7867 fail:
7868 return NULL;
7869 }
7870
7871
7872 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7873 PyObject *resultobj = 0;
7874 wxRect *arg1 = (wxRect *) 0 ;
7875 wxRect *arg2 = 0 ;
7876 int arg3 = (int) wxBOTH ;
7877 wxRect result;
7878 void *argp1 = 0 ;
7879 int res1 = 0 ;
7880 wxRect temp2 ;
7881 int val3 ;
7882 int ecode3 = 0 ;
7883 PyObject * obj0 = 0 ;
7884 PyObject * obj1 = 0 ;
7885 PyObject * obj2 = 0 ;
7886 char * kwnames[] = {
7887 (char *) "self",(char *) "r",(char *) "dir", NULL
7888 };
7889
7890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7892 if (!SWIG_IsOK(res1)) {
7893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7894 }
7895 arg1 = reinterpret_cast< wxRect * >(argp1);
7896 {
7897 arg2 = &temp2;
7898 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7899 }
7900 if (obj2) {
7901 ecode3 = SWIG_AsVal_int(obj2, &val3);
7902 if (!SWIG_IsOK(ecode3)) {
7903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7904 }
7905 arg3 = static_cast< int >(val3);
7906 }
7907 {
7908 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7909 if (PyErr_Occurred()) SWIG_fail;
7910 }
7911 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7912 return resultobj;
7913 fail:
7914 return NULL;
7915 }
7916
7917
7918 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7919 PyObject *resultobj = 0;
7920 wxRect *arg1 = (wxRect *) 0 ;
7921 int arg2 ;
7922 void *argp1 = 0 ;
7923 int res1 = 0 ;
7924 int val2 ;
7925 int ecode2 = 0 ;
7926 PyObject *swig_obj[2] ;
7927
7928 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7930 if (!SWIG_IsOK(res1)) {
7931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7932 }
7933 arg1 = reinterpret_cast< wxRect * >(argp1);
7934 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7935 if (!SWIG_IsOK(ecode2)) {
7936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7937 }
7938 arg2 = static_cast< int >(val2);
7939 if (arg1) (arg1)->x = arg2;
7940
7941 resultobj = SWIG_Py_Void();
7942 return resultobj;
7943 fail:
7944 return NULL;
7945 }
7946
7947
7948 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7949 PyObject *resultobj = 0;
7950 wxRect *arg1 = (wxRect *) 0 ;
7951 int result;
7952 void *argp1 = 0 ;
7953 int res1 = 0 ;
7954 PyObject *swig_obj[1] ;
7955
7956 if (!args) SWIG_fail;
7957 swig_obj[0] = args;
7958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7959 if (!SWIG_IsOK(res1)) {
7960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7961 }
7962 arg1 = reinterpret_cast< wxRect * >(argp1);
7963 result = (int) ((arg1)->x);
7964 resultobj = SWIG_From_int(static_cast< int >(result));
7965 return resultobj;
7966 fail:
7967 return NULL;
7968 }
7969
7970
7971 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7972 PyObject *resultobj = 0;
7973 wxRect *arg1 = (wxRect *) 0 ;
7974 int arg2 ;
7975 void *argp1 = 0 ;
7976 int res1 = 0 ;
7977 int val2 ;
7978 int ecode2 = 0 ;
7979 PyObject *swig_obj[2] ;
7980
7981 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7983 if (!SWIG_IsOK(res1)) {
7984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7985 }
7986 arg1 = reinterpret_cast< wxRect * >(argp1);
7987 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7988 if (!SWIG_IsOK(ecode2)) {
7989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7990 }
7991 arg2 = static_cast< int >(val2);
7992 if (arg1) (arg1)->y = arg2;
7993
7994 resultobj = SWIG_Py_Void();
7995 return resultobj;
7996 fail:
7997 return NULL;
7998 }
7999
8000
8001 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8002 PyObject *resultobj = 0;
8003 wxRect *arg1 = (wxRect *) 0 ;
8004 int result;
8005 void *argp1 = 0 ;
8006 int res1 = 0 ;
8007 PyObject *swig_obj[1] ;
8008
8009 if (!args) SWIG_fail;
8010 swig_obj[0] = args;
8011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8012 if (!SWIG_IsOK(res1)) {
8013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
8014 }
8015 arg1 = reinterpret_cast< wxRect * >(argp1);
8016 result = (int) ((arg1)->y);
8017 resultobj = SWIG_From_int(static_cast< int >(result));
8018 return resultobj;
8019 fail:
8020 return NULL;
8021 }
8022
8023
8024 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8025 PyObject *resultobj = 0;
8026 wxRect *arg1 = (wxRect *) 0 ;
8027 int arg2 ;
8028 void *argp1 = 0 ;
8029 int res1 = 0 ;
8030 int val2 ;
8031 int ecode2 = 0 ;
8032 PyObject *swig_obj[2] ;
8033
8034 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
8035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8036 if (!SWIG_IsOK(res1)) {
8037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
8038 }
8039 arg1 = reinterpret_cast< wxRect * >(argp1);
8040 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8041 if (!SWIG_IsOK(ecode2)) {
8042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
8043 }
8044 arg2 = static_cast< int >(val2);
8045 if (arg1) (arg1)->width = arg2;
8046
8047 resultobj = SWIG_Py_Void();
8048 return resultobj;
8049 fail:
8050 return NULL;
8051 }
8052
8053
8054 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8055 PyObject *resultobj = 0;
8056 wxRect *arg1 = (wxRect *) 0 ;
8057 int result;
8058 void *argp1 = 0 ;
8059 int res1 = 0 ;
8060 PyObject *swig_obj[1] ;
8061
8062 if (!args) SWIG_fail;
8063 swig_obj[0] = args;
8064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8065 if (!SWIG_IsOK(res1)) {
8066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8067 }
8068 arg1 = reinterpret_cast< wxRect * >(argp1);
8069 result = (int) ((arg1)->width);
8070 resultobj = SWIG_From_int(static_cast< int >(result));
8071 return resultobj;
8072 fail:
8073 return NULL;
8074 }
8075
8076
8077 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8078 PyObject *resultobj = 0;
8079 wxRect *arg1 = (wxRect *) 0 ;
8080 int arg2 ;
8081 void *argp1 = 0 ;
8082 int res1 = 0 ;
8083 int val2 ;
8084 int ecode2 = 0 ;
8085 PyObject *swig_obj[2] ;
8086
8087 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8089 if (!SWIG_IsOK(res1)) {
8090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8091 }
8092 arg1 = reinterpret_cast< wxRect * >(argp1);
8093 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8094 if (!SWIG_IsOK(ecode2)) {
8095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8096 }
8097 arg2 = static_cast< int >(val2);
8098 if (arg1) (arg1)->height = arg2;
8099
8100 resultobj = SWIG_Py_Void();
8101 return resultobj;
8102 fail:
8103 return NULL;
8104 }
8105
8106
8107 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8108 PyObject *resultobj = 0;
8109 wxRect *arg1 = (wxRect *) 0 ;
8110 int result;
8111 void *argp1 = 0 ;
8112 int res1 = 0 ;
8113 PyObject *swig_obj[1] ;
8114
8115 if (!args) SWIG_fail;
8116 swig_obj[0] = args;
8117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8118 if (!SWIG_IsOK(res1)) {
8119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8120 }
8121 arg1 = reinterpret_cast< wxRect * >(argp1);
8122 result = (int) ((arg1)->height);
8123 resultobj = SWIG_From_int(static_cast< int >(result));
8124 return resultobj;
8125 fail:
8126 return NULL;
8127 }
8128
8129
8130 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8131 PyObject *resultobj = 0;
8132 wxRect *arg1 = (wxRect *) 0 ;
8133 int arg2 = (int) 0 ;
8134 int arg3 = (int) 0 ;
8135 int arg4 = (int) 0 ;
8136 int arg5 = (int) 0 ;
8137 void *argp1 = 0 ;
8138 int res1 = 0 ;
8139 int val2 ;
8140 int ecode2 = 0 ;
8141 int val3 ;
8142 int ecode3 = 0 ;
8143 int val4 ;
8144 int ecode4 = 0 ;
8145 int val5 ;
8146 int ecode5 = 0 ;
8147 PyObject * obj0 = 0 ;
8148 PyObject * obj1 = 0 ;
8149 PyObject * obj2 = 0 ;
8150 PyObject * obj3 = 0 ;
8151 PyObject * obj4 = 0 ;
8152 char * kwnames[] = {
8153 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8154 };
8155
8156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8158 if (!SWIG_IsOK(res1)) {
8159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8160 }
8161 arg1 = reinterpret_cast< wxRect * >(argp1);
8162 if (obj1) {
8163 ecode2 = SWIG_AsVal_int(obj1, &val2);
8164 if (!SWIG_IsOK(ecode2)) {
8165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8166 }
8167 arg2 = static_cast< int >(val2);
8168 }
8169 if (obj2) {
8170 ecode3 = SWIG_AsVal_int(obj2, &val3);
8171 if (!SWIG_IsOK(ecode3)) {
8172 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8173 }
8174 arg3 = static_cast< int >(val3);
8175 }
8176 if (obj3) {
8177 ecode4 = SWIG_AsVal_int(obj3, &val4);
8178 if (!SWIG_IsOK(ecode4)) {
8179 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8180 }
8181 arg4 = static_cast< int >(val4);
8182 }
8183 if (obj4) {
8184 ecode5 = SWIG_AsVal_int(obj4, &val5);
8185 if (!SWIG_IsOK(ecode5)) {
8186 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8187 }
8188 arg5 = static_cast< int >(val5);
8189 }
8190 {
8191 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8192 if (PyErr_Occurred()) SWIG_fail;
8193 }
8194 resultobj = SWIG_Py_Void();
8195 return resultobj;
8196 fail:
8197 return NULL;
8198 }
8199
8200
8201 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8202 PyObject *resultobj = 0;
8203 wxRect *arg1 = (wxRect *) 0 ;
8204 PyObject *result = 0 ;
8205 void *argp1 = 0 ;
8206 int res1 = 0 ;
8207 PyObject *swig_obj[1] ;
8208
8209 if (!args) SWIG_fail;
8210 swig_obj[0] = args;
8211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8212 if (!SWIG_IsOK(res1)) {
8213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8214 }
8215 arg1 = reinterpret_cast< wxRect * >(argp1);
8216 {
8217 result = (PyObject *)wxRect_Get(arg1);
8218 if (PyErr_Occurred()) SWIG_fail;
8219 }
8220 resultobj = result;
8221 return resultobj;
8222 fail:
8223 return NULL;
8224 }
8225
8226
8227 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8228 PyObject *obj;
8229 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8230 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8231 return SWIG_Py_Void();
8232 }
8233
8234 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8235 return SWIG_Python_InitShadowInstance(args);
8236 }
8237
8238 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8239 PyObject *resultobj = 0;
8240 wxRect *arg1 = (wxRect *) 0 ;
8241 wxRect *arg2 = (wxRect *) 0 ;
8242 PyObject *result = 0 ;
8243 void *argp1 = 0 ;
8244 int res1 = 0 ;
8245 void *argp2 = 0 ;
8246 int res2 = 0 ;
8247 PyObject * obj0 = 0 ;
8248 PyObject * obj1 = 0 ;
8249 char * kwnames[] = {
8250 (char *) "r1",(char *) "r2", NULL
8251 };
8252
8253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8255 if (!SWIG_IsOK(res1)) {
8256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8257 }
8258 arg1 = reinterpret_cast< wxRect * >(argp1);
8259 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8260 if (!SWIG_IsOK(res2)) {
8261 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8262 }
8263 arg2 = reinterpret_cast< wxRect * >(argp2);
8264 {
8265 if (!wxPyCheckForApp()) SWIG_fail;
8266 PyThreadState* __tstate = wxPyBeginAllowThreads();
8267 result = (PyObject *)wxIntersectRect(arg1,arg2);
8268 wxPyEndAllowThreads(__tstate);
8269 if (PyErr_Occurred()) SWIG_fail;
8270 }
8271 resultobj = result;
8272 return resultobj;
8273 fail:
8274 return NULL;
8275 }
8276
8277
8278 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8279 PyObject *resultobj = 0;
8280 double arg1 = (double) 0.0 ;
8281 double arg2 = (double) 0.0 ;
8282 wxPoint2D *result = 0 ;
8283 double val1 ;
8284 int ecode1 = 0 ;
8285 double val2 ;
8286 int ecode2 = 0 ;
8287 PyObject * obj0 = 0 ;
8288 PyObject * obj1 = 0 ;
8289 char * kwnames[] = {
8290 (char *) "x",(char *) "y", NULL
8291 };
8292
8293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8294 if (obj0) {
8295 ecode1 = SWIG_AsVal_double(obj0, &val1);
8296 if (!SWIG_IsOK(ecode1)) {
8297 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8298 }
8299 arg1 = static_cast< double >(val1);
8300 }
8301 if (obj1) {
8302 ecode2 = SWIG_AsVal_double(obj1, &val2);
8303 if (!SWIG_IsOK(ecode2)) {
8304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8305 }
8306 arg2 = static_cast< double >(val2);
8307 }
8308 {
8309 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8310 if (PyErr_Occurred()) SWIG_fail;
8311 }
8312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8313 return resultobj;
8314 fail:
8315 return NULL;
8316 }
8317
8318
8319 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8320 PyObject *resultobj = 0;
8321 wxPoint2D *arg1 = 0 ;
8322 wxPoint2D *result = 0 ;
8323 wxPoint2D temp1 ;
8324 PyObject * obj0 = 0 ;
8325 char * kwnames[] = {
8326 (char *) "pt", NULL
8327 };
8328
8329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8330 {
8331 arg1 = &temp1;
8332 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8333 }
8334 {
8335 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8336 if (PyErr_Occurred()) SWIG_fail;
8337 }
8338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8339 return resultobj;
8340 fail:
8341 return NULL;
8342 }
8343
8344
8345 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8346 PyObject *resultobj = 0;
8347 wxPoint *arg1 = 0 ;
8348 wxPoint2D *result = 0 ;
8349 wxPoint temp1 ;
8350 PyObject * obj0 = 0 ;
8351 char * kwnames[] = {
8352 (char *) "pt", NULL
8353 };
8354
8355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8356 {
8357 arg1 = &temp1;
8358 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8359 }
8360 {
8361 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8362 if (PyErr_Occurred()) SWIG_fail;
8363 }
8364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8365 return resultobj;
8366 fail:
8367 return NULL;
8368 }
8369
8370
8371 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8372 PyObject *resultobj = 0;
8373 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8374 void *argp1 = 0 ;
8375 int res1 = 0 ;
8376 PyObject *swig_obj[1] ;
8377
8378 if (!args) SWIG_fail;
8379 swig_obj[0] = args;
8380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8381 if (!SWIG_IsOK(res1)) {
8382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8383 }
8384 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8385 {
8386 delete arg1;
8387
8388 if (PyErr_Occurred()) SWIG_fail;
8389 }
8390 resultobj = SWIG_Py_Void();
8391 return resultobj;
8392 fail:
8393 return NULL;
8394 }
8395
8396
8397 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8398 PyObject *resultobj = 0;
8399 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8400 int *arg2 = (int *) 0 ;
8401 int *arg3 = (int *) 0 ;
8402 void *argp1 = 0 ;
8403 int res1 = 0 ;
8404 int temp2 ;
8405 int res2 = SWIG_TMPOBJ ;
8406 int temp3 ;
8407 int res3 = SWIG_TMPOBJ ;
8408 PyObject *swig_obj[1] ;
8409
8410 arg2 = &temp2;
8411 arg3 = &temp3;
8412 if (!args) SWIG_fail;
8413 swig_obj[0] = args;
8414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8415 if (!SWIG_IsOK(res1)) {
8416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8417 }
8418 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8419 {
8420 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8421 if (PyErr_Occurred()) SWIG_fail;
8422 }
8423 resultobj = SWIG_Py_Void();
8424 if (SWIG_IsTmpObj(res2)) {
8425 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8426 } else {
8427 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8428 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8429 }
8430 if (SWIG_IsTmpObj(res3)) {
8431 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8432 } else {
8433 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8434 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8435 }
8436 return resultobj;
8437 fail:
8438 return NULL;
8439 }
8440
8441
8442 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8443 PyObject *resultobj = 0;
8444 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8445 int *arg2 = (int *) 0 ;
8446 int *arg3 = (int *) 0 ;
8447 void *argp1 = 0 ;
8448 int res1 = 0 ;
8449 int temp2 ;
8450 int res2 = SWIG_TMPOBJ ;
8451 int temp3 ;
8452 int res3 = SWIG_TMPOBJ ;
8453 PyObject *swig_obj[1] ;
8454
8455 arg2 = &temp2;
8456 arg3 = &temp3;
8457 if (!args) SWIG_fail;
8458 swig_obj[0] = args;
8459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8460 if (!SWIG_IsOK(res1)) {
8461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8462 }
8463 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8464 {
8465 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8466 if (PyErr_Occurred()) SWIG_fail;
8467 }
8468 resultobj = SWIG_Py_Void();
8469 if (SWIG_IsTmpObj(res2)) {
8470 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8471 } else {
8472 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8473 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8474 }
8475 if (SWIG_IsTmpObj(res3)) {
8476 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8477 } else {
8478 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8479 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8480 }
8481 return resultobj;
8482 fail:
8483 return NULL;
8484 }
8485
8486
8487 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8488 PyObject *resultobj = 0;
8489 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8490 double result;
8491 void *argp1 = 0 ;
8492 int res1 = 0 ;
8493 PyObject *swig_obj[1] ;
8494
8495 if (!args) SWIG_fail;
8496 swig_obj[0] = args;
8497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8498 if (!SWIG_IsOK(res1)) {
8499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8500 }
8501 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8502 {
8503 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8504 if (PyErr_Occurred()) SWIG_fail;
8505 }
8506 resultobj = SWIG_From_double(static_cast< double >(result));
8507 return resultobj;
8508 fail:
8509 return NULL;
8510 }
8511
8512
8513 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8514 PyObject *resultobj = 0;
8515 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8516 double result;
8517 void *argp1 = 0 ;
8518 int res1 = 0 ;
8519 PyObject *swig_obj[1] ;
8520
8521 if (!args) SWIG_fail;
8522 swig_obj[0] = args;
8523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8524 if (!SWIG_IsOK(res1)) {
8525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8526 }
8527 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8528 {
8529 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8530 if (PyErr_Occurred()) SWIG_fail;
8531 }
8532 resultobj = SWIG_From_double(static_cast< double >(result));
8533 return resultobj;
8534 fail:
8535 return NULL;
8536 }
8537
8538
8539 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8540 PyObject *resultobj = 0;
8541 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8542 double arg2 ;
8543 void *argp1 = 0 ;
8544 int res1 = 0 ;
8545 double val2 ;
8546 int ecode2 = 0 ;
8547 PyObject * obj0 = 0 ;
8548 PyObject * obj1 = 0 ;
8549 char * kwnames[] = {
8550 (char *) "self",(char *) "length", NULL
8551 };
8552
8553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8555 if (!SWIG_IsOK(res1)) {
8556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8557 }
8558 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8559 ecode2 = SWIG_AsVal_double(obj1, &val2);
8560 if (!SWIG_IsOK(ecode2)) {
8561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8562 }
8563 arg2 = static_cast< double >(val2);
8564 {
8565 (arg1)->SetVectorLength(arg2);
8566 if (PyErr_Occurred()) SWIG_fail;
8567 }
8568 resultobj = SWIG_Py_Void();
8569 return resultobj;
8570 fail:
8571 return NULL;
8572 }
8573
8574
8575 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8576 PyObject *resultobj = 0;
8577 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8578 double arg2 ;
8579 void *argp1 = 0 ;
8580 int res1 = 0 ;
8581 double val2 ;
8582 int ecode2 = 0 ;
8583 PyObject * obj0 = 0 ;
8584 PyObject * obj1 = 0 ;
8585 char * kwnames[] = {
8586 (char *) "self",(char *) "degrees", NULL
8587 };
8588
8589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8591 if (!SWIG_IsOK(res1)) {
8592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8593 }
8594 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8595 ecode2 = SWIG_AsVal_double(obj1, &val2);
8596 if (!SWIG_IsOK(ecode2)) {
8597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8598 }
8599 arg2 = static_cast< double >(val2);
8600 {
8601 (arg1)->SetVectorAngle(arg2);
8602 if (PyErr_Occurred()) SWIG_fail;
8603 }
8604 resultobj = SWIG_Py_Void();
8605 return resultobj;
8606 fail:
8607 return NULL;
8608 }
8609
8610
8611 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8612 PyObject *resultobj = 0;
8613 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8614 wxPoint2D *arg2 = 0 ;
8615 double result;
8616 void *argp1 = 0 ;
8617 int res1 = 0 ;
8618 wxPoint2D temp2 ;
8619 PyObject * obj0 = 0 ;
8620 PyObject * obj1 = 0 ;
8621 char * kwnames[] = {
8622 (char *) "self",(char *) "pt", NULL
8623 };
8624
8625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8627 if (!SWIG_IsOK(res1)) {
8628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8629 }
8630 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8631 {
8632 arg2 = &temp2;
8633 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8634 }
8635 {
8636 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8637 if (PyErr_Occurred()) SWIG_fail;
8638 }
8639 resultobj = SWIG_From_double(static_cast< double >(result));
8640 return resultobj;
8641 fail:
8642 return NULL;
8643 }
8644
8645
8646 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8647 PyObject *resultobj = 0;
8648 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8649 wxPoint2D *arg2 = 0 ;
8650 double result;
8651 void *argp1 = 0 ;
8652 int res1 = 0 ;
8653 wxPoint2D temp2 ;
8654 PyObject * obj0 = 0 ;
8655 PyObject * obj1 = 0 ;
8656 char * kwnames[] = {
8657 (char *) "self",(char *) "pt", NULL
8658 };
8659
8660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8662 if (!SWIG_IsOK(res1)) {
8663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8664 }
8665 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8666 {
8667 arg2 = &temp2;
8668 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8669 }
8670 {
8671 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8672 if (PyErr_Occurred()) SWIG_fail;
8673 }
8674 resultobj = SWIG_From_double(static_cast< double >(result));
8675 return resultobj;
8676 fail:
8677 return NULL;
8678 }
8679
8680
8681 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8682 PyObject *resultobj = 0;
8683 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8684 wxPoint2D *arg2 = 0 ;
8685 double result;
8686 void *argp1 = 0 ;
8687 int res1 = 0 ;
8688 wxPoint2D temp2 ;
8689 PyObject * obj0 = 0 ;
8690 PyObject * obj1 = 0 ;
8691 char * kwnames[] = {
8692 (char *) "self",(char *) "vec", NULL
8693 };
8694
8695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8697 if (!SWIG_IsOK(res1)) {
8698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8699 }
8700 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8701 {
8702 arg2 = &temp2;
8703 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8704 }
8705 {
8706 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8707 if (PyErr_Occurred()) SWIG_fail;
8708 }
8709 resultobj = SWIG_From_double(static_cast< double >(result));
8710 return resultobj;
8711 fail:
8712 return NULL;
8713 }
8714
8715
8716 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8717 PyObject *resultobj = 0;
8718 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8719 wxPoint2D *arg2 = 0 ;
8720 double result;
8721 void *argp1 = 0 ;
8722 int res1 = 0 ;
8723 wxPoint2D temp2 ;
8724 PyObject * obj0 = 0 ;
8725 PyObject * obj1 = 0 ;
8726 char * kwnames[] = {
8727 (char *) "self",(char *) "vec", NULL
8728 };
8729
8730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8732 if (!SWIG_IsOK(res1)) {
8733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8734 }
8735 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8736 {
8737 arg2 = &temp2;
8738 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8739 }
8740 {
8741 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8742 if (PyErr_Occurred()) SWIG_fail;
8743 }
8744 resultobj = SWIG_From_double(static_cast< double >(result));
8745 return resultobj;
8746 fail:
8747 return NULL;
8748 }
8749
8750
8751 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8752 PyObject *resultobj = 0;
8753 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8754 wxPoint2D result;
8755 void *argp1 = 0 ;
8756 int res1 = 0 ;
8757 PyObject *swig_obj[1] ;
8758
8759 if (!args) SWIG_fail;
8760 swig_obj[0] = args;
8761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8762 if (!SWIG_IsOK(res1)) {
8763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8764 }
8765 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8766 {
8767 result = (arg1)->operator -();
8768 if (PyErr_Occurred()) SWIG_fail;
8769 }
8770 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8771 return resultobj;
8772 fail:
8773 return NULL;
8774 }
8775
8776
8777 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8778 PyObject *resultobj = 0;
8779 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8780 wxPoint2D *arg2 = 0 ;
8781 wxPoint2D *result = 0 ;
8782 void *argp1 = 0 ;
8783 int res1 = 0 ;
8784 wxPoint2D temp2 ;
8785 PyObject * obj0 = 0 ;
8786 PyObject * obj1 = 0 ;
8787 char * kwnames[] = {
8788 (char *) "self",(char *) "pt", NULL
8789 };
8790
8791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8793 if (!SWIG_IsOK(res1)) {
8794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8795 }
8796 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8797 {
8798 arg2 = &temp2;
8799 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8800 }
8801 {
8802 {
8803 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8804 result = (wxPoint2D *) &_result_ref;
8805 }
8806 if (PyErr_Occurred()) SWIG_fail;
8807 }
8808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8809 return resultobj;
8810 fail:
8811 return NULL;
8812 }
8813
8814
8815 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8816 PyObject *resultobj = 0;
8817 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8818 wxPoint2D *arg2 = 0 ;
8819 wxPoint2D *result = 0 ;
8820 void *argp1 = 0 ;
8821 int res1 = 0 ;
8822 wxPoint2D temp2 ;
8823 PyObject * obj0 = 0 ;
8824 PyObject * obj1 = 0 ;
8825 char * kwnames[] = {
8826 (char *) "self",(char *) "pt", NULL
8827 };
8828
8829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8831 if (!SWIG_IsOK(res1)) {
8832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8833 }
8834 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8835 {
8836 arg2 = &temp2;
8837 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8838 }
8839 {
8840 {
8841 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8842 result = (wxPoint2D *) &_result_ref;
8843 }
8844 if (PyErr_Occurred()) SWIG_fail;
8845 }
8846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8847 return resultobj;
8848 fail:
8849 return NULL;
8850 }
8851
8852
8853 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8854 PyObject *resultobj = 0;
8855 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8856 wxPoint2D *arg2 = 0 ;
8857 wxPoint2D *result = 0 ;
8858 void *argp1 = 0 ;
8859 int res1 = 0 ;
8860 wxPoint2D temp2 ;
8861 PyObject * obj0 = 0 ;
8862 PyObject * obj1 = 0 ;
8863 char * kwnames[] = {
8864 (char *) "self",(char *) "pt", NULL
8865 };
8866
8867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8869 if (!SWIG_IsOK(res1)) {
8870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8871 }
8872 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8873 {
8874 arg2 = &temp2;
8875 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8876 }
8877 {
8878 {
8879 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8880 result = (wxPoint2D *) &_result_ref;
8881 }
8882 if (PyErr_Occurred()) SWIG_fail;
8883 }
8884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8885 return resultobj;
8886 fail:
8887 return NULL;
8888 }
8889
8890
8891 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8892 PyObject *resultobj = 0;
8893 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8894 wxPoint2D *arg2 = 0 ;
8895 wxPoint2D *result = 0 ;
8896 void *argp1 = 0 ;
8897 int res1 = 0 ;
8898 wxPoint2D temp2 ;
8899 PyObject * obj0 = 0 ;
8900 PyObject * obj1 = 0 ;
8901 char * kwnames[] = {
8902 (char *) "self",(char *) "pt", NULL
8903 };
8904
8905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8907 if (!SWIG_IsOK(res1)) {
8908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8909 }
8910 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8911 {
8912 arg2 = &temp2;
8913 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8914 }
8915 {
8916 {
8917 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8918 result = (wxPoint2D *) &_result_ref;
8919 }
8920 if (PyErr_Occurred()) SWIG_fail;
8921 }
8922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8923 return resultobj;
8924 fail:
8925 return NULL;
8926 }
8927
8928
8929 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8930 PyObject *resultobj = 0;
8931 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8932 PyObject *arg2 = (PyObject *) 0 ;
8933 bool result;
8934 void *argp1 = 0 ;
8935 int res1 = 0 ;
8936 PyObject * obj0 = 0 ;
8937 PyObject * obj1 = 0 ;
8938 char * kwnames[] = {
8939 (char *) "self",(char *) "other", NULL
8940 };
8941
8942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8944 if (!SWIG_IsOK(res1)) {
8945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8946 }
8947 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8948 arg2 = obj1;
8949 {
8950 result = (bool)wxPoint2D___eq__(arg1,arg2);
8951 if (PyErr_Occurred()) SWIG_fail;
8952 }
8953 {
8954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8955 }
8956 return resultobj;
8957 fail:
8958 return NULL;
8959 }
8960
8961
8962 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8963 PyObject *resultobj = 0;
8964 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8965 PyObject *arg2 = (PyObject *) 0 ;
8966 bool result;
8967 void *argp1 = 0 ;
8968 int res1 = 0 ;
8969 PyObject * obj0 = 0 ;
8970 PyObject * obj1 = 0 ;
8971 char * kwnames[] = {
8972 (char *) "self",(char *) "other", NULL
8973 };
8974
8975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8977 if (!SWIG_IsOK(res1)) {
8978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8979 }
8980 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8981 arg2 = obj1;
8982 {
8983 result = (bool)wxPoint2D___ne__(arg1,arg2);
8984 if (PyErr_Occurred()) SWIG_fail;
8985 }
8986 {
8987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8988 }
8989 return resultobj;
8990 fail:
8991 return NULL;
8992 }
8993
8994
8995 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8996 PyObject *resultobj = 0;
8997 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8998 double arg2 ;
8999 void *argp1 = 0 ;
9000 int res1 = 0 ;
9001 double val2 ;
9002 int ecode2 = 0 ;
9003 PyObject *swig_obj[2] ;
9004
9005 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
9006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9007 if (!SWIG_IsOK(res1)) {
9008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9009 }
9010 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9011 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9012 if (!SWIG_IsOK(ecode2)) {
9013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
9014 }
9015 arg2 = static_cast< double >(val2);
9016 if (arg1) (arg1)->m_x = arg2;
9017
9018 resultobj = SWIG_Py_Void();
9019 return resultobj;
9020 fail:
9021 return NULL;
9022 }
9023
9024
9025 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9026 PyObject *resultobj = 0;
9027 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9028 double result;
9029 void *argp1 = 0 ;
9030 int res1 = 0 ;
9031 PyObject *swig_obj[1] ;
9032
9033 if (!args) SWIG_fail;
9034 swig_obj[0] = args;
9035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9036 if (!SWIG_IsOK(res1)) {
9037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9038 }
9039 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9040 result = (double) ((arg1)->m_x);
9041 resultobj = SWIG_From_double(static_cast< double >(result));
9042 return resultobj;
9043 fail:
9044 return NULL;
9045 }
9046
9047
9048 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9049 PyObject *resultobj = 0;
9050 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9051 double arg2 ;
9052 void *argp1 = 0 ;
9053 int res1 = 0 ;
9054 double val2 ;
9055 int ecode2 = 0 ;
9056 PyObject *swig_obj[2] ;
9057
9058 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9060 if (!SWIG_IsOK(res1)) {
9061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9062 }
9063 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9064 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9065 if (!SWIG_IsOK(ecode2)) {
9066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9067 }
9068 arg2 = static_cast< double >(val2);
9069 if (arg1) (arg1)->m_y = arg2;
9070
9071 resultobj = SWIG_Py_Void();
9072 return resultobj;
9073 fail:
9074 return NULL;
9075 }
9076
9077
9078 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9079 PyObject *resultobj = 0;
9080 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9081 double result;
9082 void *argp1 = 0 ;
9083 int res1 = 0 ;
9084 PyObject *swig_obj[1] ;
9085
9086 if (!args) SWIG_fail;
9087 swig_obj[0] = args;
9088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9089 if (!SWIG_IsOK(res1)) {
9090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9091 }
9092 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9093 result = (double) ((arg1)->m_y);
9094 resultobj = SWIG_From_double(static_cast< double >(result));
9095 return resultobj;
9096 fail:
9097 return NULL;
9098 }
9099
9100
9101 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9102 PyObject *resultobj = 0;
9103 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9104 double arg2 = (double) 0 ;
9105 double arg3 = (double) 0 ;
9106 void *argp1 = 0 ;
9107 int res1 = 0 ;
9108 double val2 ;
9109 int ecode2 = 0 ;
9110 double val3 ;
9111 int ecode3 = 0 ;
9112 PyObject * obj0 = 0 ;
9113 PyObject * obj1 = 0 ;
9114 PyObject * obj2 = 0 ;
9115 char * kwnames[] = {
9116 (char *) "self",(char *) "x",(char *) "y", NULL
9117 };
9118
9119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9121 if (!SWIG_IsOK(res1)) {
9122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9123 }
9124 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9125 if (obj1) {
9126 ecode2 = SWIG_AsVal_double(obj1, &val2);
9127 if (!SWIG_IsOK(ecode2)) {
9128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9129 }
9130 arg2 = static_cast< double >(val2);
9131 }
9132 if (obj2) {
9133 ecode3 = SWIG_AsVal_double(obj2, &val3);
9134 if (!SWIG_IsOK(ecode3)) {
9135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9136 }
9137 arg3 = static_cast< double >(val3);
9138 }
9139 {
9140 wxPoint2D_Set(arg1,arg2,arg3);
9141 if (PyErr_Occurred()) SWIG_fail;
9142 }
9143 resultobj = SWIG_Py_Void();
9144 return resultobj;
9145 fail:
9146 return NULL;
9147 }
9148
9149
9150 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9151 PyObject *resultobj = 0;
9152 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9153 PyObject *result = 0 ;
9154 void *argp1 = 0 ;
9155 int res1 = 0 ;
9156 PyObject *swig_obj[1] ;
9157
9158 if (!args) SWIG_fail;
9159 swig_obj[0] = args;
9160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9161 if (!SWIG_IsOK(res1)) {
9162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9163 }
9164 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9165 {
9166 result = (PyObject *)wxPoint2D_Get(arg1);
9167 if (PyErr_Occurred()) SWIG_fail;
9168 }
9169 resultobj = result;
9170 return resultobj;
9171 fail:
9172 return NULL;
9173 }
9174
9175
9176 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9177 PyObject *obj;
9178 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9179 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9180 return SWIG_Py_Void();
9181 }
9182
9183 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9184 return SWIG_Python_InitShadowInstance(args);
9185 }
9186
9187 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9188 PyObject *resultobj = 0;
9189 wxDouble arg1 = (wxDouble) 0.0 ;
9190 wxDouble arg2 = (wxDouble) 0.0 ;
9191 wxDouble arg3 = (wxDouble) 0.0 ;
9192 wxDouble arg4 = (wxDouble) 0.0 ;
9193 wxRect2D *result = 0 ;
9194 void *argp1 ;
9195 int res1 = 0 ;
9196 void *argp2 ;
9197 int res2 = 0 ;
9198 void *argp3 ;
9199 int res3 = 0 ;
9200 void *argp4 ;
9201 int res4 = 0 ;
9202 PyObject * obj0 = 0 ;
9203 PyObject * obj1 = 0 ;
9204 PyObject * obj2 = 0 ;
9205 PyObject * obj3 = 0 ;
9206 char * kwnames[] = {
9207 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9208 };
9209
9210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9211 if (obj0) {
9212 {
9213 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9214 if (!SWIG_IsOK(res1)) {
9215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9216 }
9217 if (!argp1) {
9218 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9219 } else {
9220 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9221 arg1 = *temp;
9222 if (SWIG_IsNewObj(res1)) delete temp;
9223 }
9224 }
9225 }
9226 if (obj1) {
9227 {
9228 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9229 if (!SWIG_IsOK(res2)) {
9230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9231 }
9232 if (!argp2) {
9233 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9234 } else {
9235 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9236 arg2 = *temp;
9237 if (SWIG_IsNewObj(res2)) delete temp;
9238 }
9239 }
9240 }
9241 if (obj2) {
9242 {
9243 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9244 if (!SWIG_IsOK(res3)) {
9245 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9246 }
9247 if (!argp3) {
9248 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9249 } else {
9250 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9251 arg3 = *temp;
9252 if (SWIG_IsNewObj(res3)) delete temp;
9253 }
9254 }
9255 }
9256 if (obj3) {
9257 {
9258 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9259 if (!SWIG_IsOK(res4)) {
9260 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9261 }
9262 if (!argp4) {
9263 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9264 } else {
9265 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9266 arg4 = *temp;
9267 if (SWIG_IsNewObj(res4)) delete temp;
9268 }
9269 }
9270 }
9271 {
9272 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9273 if (PyErr_Occurred()) SWIG_fail;
9274 }
9275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9276 return resultobj;
9277 fail:
9278 return NULL;
9279 }
9280
9281
9282 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9283 PyObject *resultobj = 0;
9284 wxRect2D *arg1 = (wxRect2D *) 0 ;
9285 void *argp1 = 0 ;
9286 int res1 = 0 ;
9287 PyObject *swig_obj[1] ;
9288
9289 if (!args) SWIG_fail;
9290 swig_obj[0] = args;
9291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9292 if (!SWIG_IsOK(res1)) {
9293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9294 }
9295 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9296 {
9297 delete arg1;
9298
9299 if (PyErr_Occurred()) SWIG_fail;
9300 }
9301 resultobj = SWIG_Py_Void();
9302 return resultobj;
9303 fail:
9304 return NULL;
9305 }
9306
9307
9308 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9309 PyObject *resultobj = 0;
9310 wxRect2D *arg1 = (wxRect2D *) 0 ;
9311 wxPoint2D result;
9312 void *argp1 = 0 ;
9313 int res1 = 0 ;
9314 PyObject *swig_obj[1] ;
9315
9316 if (!args) SWIG_fail;
9317 swig_obj[0] = args;
9318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9319 if (!SWIG_IsOK(res1)) {
9320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9321 }
9322 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9323 {
9324 result = (arg1)->GetPosition();
9325 if (PyErr_Occurred()) SWIG_fail;
9326 }
9327 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9328 return resultobj;
9329 fail:
9330 return NULL;
9331 }
9332
9333
9334 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9335 PyObject *resultobj = 0;
9336 wxRect2D *arg1 = (wxRect2D *) 0 ;
9337 wxSize result;
9338 void *argp1 = 0 ;
9339 int res1 = 0 ;
9340 PyObject *swig_obj[1] ;
9341
9342 if (!args) SWIG_fail;
9343 swig_obj[0] = args;
9344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9345 if (!SWIG_IsOK(res1)) {
9346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9347 }
9348 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9349 {
9350 result = (arg1)->GetSize();
9351 if (PyErr_Occurred()) SWIG_fail;
9352 }
9353 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9354 return resultobj;
9355 fail:
9356 return NULL;
9357 }
9358
9359
9360 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9361 PyObject *resultobj = 0;
9362 wxRect2D *arg1 = (wxRect2D *) 0 ;
9363 wxDouble result;
9364 void *argp1 = 0 ;
9365 int res1 = 0 ;
9366 PyObject *swig_obj[1] ;
9367
9368 if (!args) SWIG_fail;
9369 swig_obj[0] = args;
9370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9371 if (!SWIG_IsOK(res1)) {
9372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9373 }
9374 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9375 {
9376 result = ((wxRect2D const *)arg1)->GetLeft();
9377 if (PyErr_Occurred()) SWIG_fail;
9378 }
9379 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9380 return resultobj;
9381 fail:
9382 return NULL;
9383 }
9384
9385
9386 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9387 PyObject *resultobj = 0;
9388 wxRect2D *arg1 = (wxRect2D *) 0 ;
9389 wxDouble arg2 ;
9390 void *argp1 = 0 ;
9391 int res1 = 0 ;
9392 void *argp2 ;
9393 int res2 = 0 ;
9394 PyObject * obj0 = 0 ;
9395 PyObject * obj1 = 0 ;
9396 char * kwnames[] = {
9397 (char *) "self",(char *) "n", NULL
9398 };
9399
9400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9402 if (!SWIG_IsOK(res1)) {
9403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9404 }
9405 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9406 {
9407 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9408 if (!SWIG_IsOK(res2)) {
9409 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9410 }
9411 if (!argp2) {
9412 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9413 } else {
9414 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9415 arg2 = *temp;
9416 if (SWIG_IsNewObj(res2)) delete temp;
9417 }
9418 }
9419 {
9420 (arg1)->SetLeft(arg2);
9421 if (PyErr_Occurred()) SWIG_fail;
9422 }
9423 resultobj = SWIG_Py_Void();
9424 return resultobj;
9425 fail:
9426 return NULL;
9427 }
9428
9429
9430 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9431 PyObject *resultobj = 0;
9432 wxRect2D *arg1 = (wxRect2D *) 0 ;
9433 wxDouble arg2 ;
9434 void *argp1 = 0 ;
9435 int res1 = 0 ;
9436 void *argp2 ;
9437 int res2 = 0 ;
9438 PyObject * obj0 = 0 ;
9439 PyObject * obj1 = 0 ;
9440 char * kwnames[] = {
9441 (char *) "self",(char *) "n", NULL
9442 };
9443
9444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9446 if (!SWIG_IsOK(res1)) {
9447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9448 }
9449 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9450 {
9451 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9452 if (!SWIG_IsOK(res2)) {
9453 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9454 }
9455 if (!argp2) {
9456 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9457 } else {
9458 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9459 arg2 = *temp;
9460 if (SWIG_IsNewObj(res2)) delete temp;
9461 }
9462 }
9463 {
9464 (arg1)->MoveLeftTo(arg2);
9465 if (PyErr_Occurred()) SWIG_fail;
9466 }
9467 resultobj = SWIG_Py_Void();
9468 return resultobj;
9469 fail:
9470 return NULL;
9471 }
9472
9473
9474 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9475 PyObject *resultobj = 0;
9476 wxRect2D *arg1 = (wxRect2D *) 0 ;
9477 wxDouble result;
9478 void *argp1 = 0 ;
9479 int res1 = 0 ;
9480 PyObject *swig_obj[1] ;
9481
9482 if (!args) SWIG_fail;
9483 swig_obj[0] = args;
9484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9485 if (!SWIG_IsOK(res1)) {
9486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9487 }
9488 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9489 {
9490 result = ((wxRect2D const *)arg1)->GetTop();
9491 if (PyErr_Occurred()) SWIG_fail;
9492 }
9493 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9494 return resultobj;
9495 fail:
9496 return NULL;
9497 }
9498
9499
9500 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9501 PyObject *resultobj = 0;
9502 wxRect2D *arg1 = (wxRect2D *) 0 ;
9503 wxDouble arg2 ;
9504 void *argp1 = 0 ;
9505 int res1 = 0 ;
9506 void *argp2 ;
9507 int res2 = 0 ;
9508 PyObject * obj0 = 0 ;
9509 PyObject * obj1 = 0 ;
9510 char * kwnames[] = {
9511 (char *) "self",(char *) "n", NULL
9512 };
9513
9514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9516 if (!SWIG_IsOK(res1)) {
9517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9518 }
9519 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9520 {
9521 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9522 if (!SWIG_IsOK(res2)) {
9523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9524 }
9525 if (!argp2) {
9526 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9527 } else {
9528 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9529 arg2 = *temp;
9530 if (SWIG_IsNewObj(res2)) delete temp;
9531 }
9532 }
9533 {
9534 (arg1)->SetTop(arg2);
9535 if (PyErr_Occurred()) SWIG_fail;
9536 }
9537 resultobj = SWIG_Py_Void();
9538 return resultobj;
9539 fail:
9540 return NULL;
9541 }
9542
9543
9544 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9545 PyObject *resultobj = 0;
9546 wxRect2D *arg1 = (wxRect2D *) 0 ;
9547 wxDouble arg2 ;
9548 void *argp1 = 0 ;
9549 int res1 = 0 ;
9550 void *argp2 ;
9551 int res2 = 0 ;
9552 PyObject * obj0 = 0 ;
9553 PyObject * obj1 = 0 ;
9554 char * kwnames[] = {
9555 (char *) "self",(char *) "n", NULL
9556 };
9557
9558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9560 if (!SWIG_IsOK(res1)) {
9561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9562 }
9563 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9564 {
9565 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9566 if (!SWIG_IsOK(res2)) {
9567 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9568 }
9569 if (!argp2) {
9570 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9571 } else {
9572 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9573 arg2 = *temp;
9574 if (SWIG_IsNewObj(res2)) delete temp;
9575 }
9576 }
9577 {
9578 (arg1)->MoveTopTo(arg2);
9579 if (PyErr_Occurred()) SWIG_fail;
9580 }
9581 resultobj = SWIG_Py_Void();
9582 return resultobj;
9583 fail:
9584 return NULL;
9585 }
9586
9587
9588 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9589 PyObject *resultobj = 0;
9590 wxRect2D *arg1 = (wxRect2D *) 0 ;
9591 wxDouble result;
9592 void *argp1 = 0 ;
9593 int res1 = 0 ;
9594 PyObject *swig_obj[1] ;
9595
9596 if (!args) SWIG_fail;
9597 swig_obj[0] = args;
9598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9599 if (!SWIG_IsOK(res1)) {
9600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9601 }
9602 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9603 {
9604 result = ((wxRect2D const *)arg1)->GetBottom();
9605 if (PyErr_Occurred()) SWIG_fail;
9606 }
9607 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9608 return resultobj;
9609 fail:
9610 return NULL;
9611 }
9612
9613
9614 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9615 PyObject *resultobj = 0;
9616 wxRect2D *arg1 = (wxRect2D *) 0 ;
9617 wxDouble arg2 ;
9618 void *argp1 = 0 ;
9619 int res1 = 0 ;
9620 void *argp2 ;
9621 int res2 = 0 ;
9622 PyObject * obj0 = 0 ;
9623 PyObject * obj1 = 0 ;
9624 char * kwnames[] = {
9625 (char *) "self",(char *) "n", NULL
9626 };
9627
9628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9630 if (!SWIG_IsOK(res1)) {
9631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9632 }
9633 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9634 {
9635 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9636 if (!SWIG_IsOK(res2)) {
9637 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9638 }
9639 if (!argp2) {
9640 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9641 } else {
9642 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9643 arg2 = *temp;
9644 if (SWIG_IsNewObj(res2)) delete temp;
9645 }
9646 }
9647 {
9648 (arg1)->SetBottom(arg2);
9649 if (PyErr_Occurred()) SWIG_fail;
9650 }
9651 resultobj = SWIG_Py_Void();
9652 return resultobj;
9653 fail:
9654 return NULL;
9655 }
9656
9657
9658 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9659 PyObject *resultobj = 0;
9660 wxRect2D *arg1 = (wxRect2D *) 0 ;
9661 wxDouble arg2 ;
9662 void *argp1 = 0 ;
9663 int res1 = 0 ;
9664 void *argp2 ;
9665 int res2 = 0 ;
9666 PyObject * obj0 = 0 ;
9667 PyObject * obj1 = 0 ;
9668 char * kwnames[] = {
9669 (char *) "self",(char *) "n", NULL
9670 };
9671
9672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9674 if (!SWIG_IsOK(res1)) {
9675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9676 }
9677 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9678 {
9679 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9680 if (!SWIG_IsOK(res2)) {
9681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9682 }
9683 if (!argp2) {
9684 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9685 } else {
9686 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9687 arg2 = *temp;
9688 if (SWIG_IsNewObj(res2)) delete temp;
9689 }
9690 }
9691 {
9692 (arg1)->MoveBottomTo(arg2);
9693 if (PyErr_Occurred()) SWIG_fail;
9694 }
9695 resultobj = SWIG_Py_Void();
9696 return resultobj;
9697 fail:
9698 return NULL;
9699 }
9700
9701
9702 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9703 PyObject *resultobj = 0;
9704 wxRect2D *arg1 = (wxRect2D *) 0 ;
9705 wxDouble result;
9706 void *argp1 = 0 ;
9707 int res1 = 0 ;
9708 PyObject *swig_obj[1] ;
9709
9710 if (!args) SWIG_fail;
9711 swig_obj[0] = args;
9712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9713 if (!SWIG_IsOK(res1)) {
9714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9715 }
9716 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9717 {
9718 result = ((wxRect2D const *)arg1)->GetRight();
9719 if (PyErr_Occurred()) SWIG_fail;
9720 }
9721 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9722 return resultobj;
9723 fail:
9724 return NULL;
9725 }
9726
9727
9728 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9729 PyObject *resultobj = 0;
9730 wxRect2D *arg1 = (wxRect2D *) 0 ;
9731 wxDouble arg2 ;
9732 void *argp1 = 0 ;
9733 int res1 = 0 ;
9734 void *argp2 ;
9735 int res2 = 0 ;
9736 PyObject * obj0 = 0 ;
9737 PyObject * obj1 = 0 ;
9738 char * kwnames[] = {
9739 (char *) "self",(char *) "n", NULL
9740 };
9741
9742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9744 if (!SWIG_IsOK(res1)) {
9745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9746 }
9747 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9748 {
9749 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9750 if (!SWIG_IsOK(res2)) {
9751 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9752 }
9753 if (!argp2) {
9754 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9755 } else {
9756 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9757 arg2 = *temp;
9758 if (SWIG_IsNewObj(res2)) delete temp;
9759 }
9760 }
9761 {
9762 (arg1)->SetRight(arg2);
9763 if (PyErr_Occurred()) SWIG_fail;
9764 }
9765 resultobj = SWIG_Py_Void();
9766 return resultobj;
9767 fail:
9768 return NULL;
9769 }
9770
9771
9772 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9773 PyObject *resultobj = 0;
9774 wxRect2D *arg1 = (wxRect2D *) 0 ;
9775 wxDouble arg2 ;
9776 void *argp1 = 0 ;
9777 int res1 = 0 ;
9778 void *argp2 ;
9779 int res2 = 0 ;
9780 PyObject * obj0 = 0 ;
9781 PyObject * obj1 = 0 ;
9782 char * kwnames[] = {
9783 (char *) "self",(char *) "n", NULL
9784 };
9785
9786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9788 if (!SWIG_IsOK(res1)) {
9789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9790 }
9791 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9792 {
9793 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9794 if (!SWIG_IsOK(res2)) {
9795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9796 }
9797 if (!argp2) {
9798 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9799 } else {
9800 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9801 arg2 = *temp;
9802 if (SWIG_IsNewObj(res2)) delete temp;
9803 }
9804 }
9805 {
9806 (arg1)->MoveRightTo(arg2);
9807 if (PyErr_Occurred()) SWIG_fail;
9808 }
9809 resultobj = SWIG_Py_Void();
9810 return resultobj;
9811 fail:
9812 return NULL;
9813 }
9814
9815
9816 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9817 PyObject *resultobj = 0;
9818 wxRect2D *arg1 = (wxRect2D *) 0 ;
9819 wxPoint2D result;
9820 void *argp1 = 0 ;
9821 int res1 = 0 ;
9822 PyObject *swig_obj[1] ;
9823
9824 if (!args) SWIG_fail;
9825 swig_obj[0] = args;
9826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9827 if (!SWIG_IsOK(res1)) {
9828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9829 }
9830 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9831 {
9832 result = ((wxRect2D const *)arg1)->GetLeftTop();
9833 if (PyErr_Occurred()) SWIG_fail;
9834 }
9835 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9836 return resultobj;
9837 fail:
9838 return NULL;
9839 }
9840
9841
9842 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9843 PyObject *resultobj = 0;
9844 wxRect2D *arg1 = (wxRect2D *) 0 ;
9845 wxPoint2D *arg2 = 0 ;
9846 void *argp1 = 0 ;
9847 int res1 = 0 ;
9848 wxPoint2D temp2 ;
9849 PyObject * obj0 = 0 ;
9850 PyObject * obj1 = 0 ;
9851 char * kwnames[] = {
9852 (char *) "self",(char *) "pt", NULL
9853 };
9854
9855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9857 if (!SWIG_IsOK(res1)) {
9858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9859 }
9860 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9861 {
9862 arg2 = &temp2;
9863 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9864 }
9865 {
9866 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9867 if (PyErr_Occurred()) SWIG_fail;
9868 }
9869 resultobj = SWIG_Py_Void();
9870 return resultobj;
9871 fail:
9872 return NULL;
9873 }
9874
9875
9876 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9877 PyObject *resultobj = 0;
9878 wxRect2D *arg1 = (wxRect2D *) 0 ;
9879 wxPoint2D *arg2 = 0 ;
9880 void *argp1 = 0 ;
9881 int res1 = 0 ;
9882 wxPoint2D temp2 ;
9883 PyObject * obj0 = 0 ;
9884 PyObject * obj1 = 0 ;
9885 char * kwnames[] = {
9886 (char *) "self",(char *) "pt", NULL
9887 };
9888
9889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9891 if (!SWIG_IsOK(res1)) {
9892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9893 }
9894 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9895 {
9896 arg2 = &temp2;
9897 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9898 }
9899 {
9900 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9901 if (PyErr_Occurred()) SWIG_fail;
9902 }
9903 resultobj = SWIG_Py_Void();
9904 return resultobj;
9905 fail:
9906 return NULL;
9907 }
9908
9909
9910 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9911 PyObject *resultobj = 0;
9912 wxRect2D *arg1 = (wxRect2D *) 0 ;
9913 wxPoint2D result;
9914 void *argp1 = 0 ;
9915 int res1 = 0 ;
9916 PyObject *swig_obj[1] ;
9917
9918 if (!args) SWIG_fail;
9919 swig_obj[0] = args;
9920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9921 if (!SWIG_IsOK(res1)) {
9922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9923 }
9924 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9925 {
9926 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9927 if (PyErr_Occurred()) SWIG_fail;
9928 }
9929 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9930 return resultobj;
9931 fail:
9932 return NULL;
9933 }
9934
9935
9936 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9937 PyObject *resultobj = 0;
9938 wxRect2D *arg1 = (wxRect2D *) 0 ;
9939 wxPoint2D *arg2 = 0 ;
9940 void *argp1 = 0 ;
9941 int res1 = 0 ;
9942 wxPoint2D temp2 ;
9943 PyObject * obj0 = 0 ;
9944 PyObject * obj1 = 0 ;
9945 char * kwnames[] = {
9946 (char *) "self",(char *) "pt", NULL
9947 };
9948
9949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9951 if (!SWIG_IsOK(res1)) {
9952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9953 }
9954 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9955 {
9956 arg2 = &temp2;
9957 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9958 }
9959 {
9960 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9961 if (PyErr_Occurred()) SWIG_fail;
9962 }
9963 resultobj = SWIG_Py_Void();
9964 return resultobj;
9965 fail:
9966 return NULL;
9967 }
9968
9969
9970 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9971 PyObject *resultobj = 0;
9972 wxRect2D *arg1 = (wxRect2D *) 0 ;
9973 wxPoint2D *arg2 = 0 ;
9974 void *argp1 = 0 ;
9975 int res1 = 0 ;
9976 wxPoint2D temp2 ;
9977 PyObject * obj0 = 0 ;
9978 PyObject * obj1 = 0 ;
9979 char * kwnames[] = {
9980 (char *) "self",(char *) "pt", NULL
9981 };
9982
9983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9985 if (!SWIG_IsOK(res1)) {
9986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9987 }
9988 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9989 {
9990 arg2 = &temp2;
9991 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9992 }
9993 {
9994 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
9995 if (PyErr_Occurred()) SWIG_fail;
9996 }
9997 resultobj = SWIG_Py_Void();
9998 return resultobj;
9999 fail:
10000 return NULL;
10001 }
10002
10003
10004 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10005 PyObject *resultobj = 0;
10006 wxRect2D *arg1 = (wxRect2D *) 0 ;
10007 wxPoint2D result;
10008 void *argp1 = 0 ;
10009 int res1 = 0 ;
10010 PyObject *swig_obj[1] ;
10011
10012 if (!args) SWIG_fail;
10013 swig_obj[0] = args;
10014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10015 if (!SWIG_IsOK(res1)) {
10016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10017 }
10018 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10019 {
10020 result = ((wxRect2D const *)arg1)->GetRightTop();
10021 if (PyErr_Occurred()) SWIG_fail;
10022 }
10023 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10024 return resultobj;
10025 fail:
10026 return NULL;
10027 }
10028
10029
10030 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10031 PyObject *resultobj = 0;
10032 wxRect2D *arg1 = (wxRect2D *) 0 ;
10033 wxPoint2D *arg2 = 0 ;
10034 void *argp1 = 0 ;
10035 int res1 = 0 ;
10036 wxPoint2D temp2 ;
10037 PyObject * obj0 = 0 ;
10038 PyObject * obj1 = 0 ;
10039 char * kwnames[] = {
10040 (char *) "self",(char *) "pt", NULL
10041 };
10042
10043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
10044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10045 if (!SWIG_IsOK(res1)) {
10046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
10047 }
10048 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10049 {
10050 arg2 = &temp2;
10051 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10052 }
10053 {
10054 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
10055 if (PyErr_Occurred()) SWIG_fail;
10056 }
10057 resultobj = SWIG_Py_Void();
10058 return resultobj;
10059 fail:
10060 return NULL;
10061 }
10062
10063
10064 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10065 PyObject *resultobj = 0;
10066 wxRect2D *arg1 = (wxRect2D *) 0 ;
10067 wxPoint2D *arg2 = 0 ;
10068 void *argp1 = 0 ;
10069 int res1 = 0 ;
10070 wxPoint2D temp2 ;
10071 PyObject * obj0 = 0 ;
10072 PyObject * obj1 = 0 ;
10073 char * kwnames[] = {
10074 (char *) "self",(char *) "pt", NULL
10075 };
10076
10077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10079 if (!SWIG_IsOK(res1)) {
10080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10081 }
10082 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10083 {
10084 arg2 = &temp2;
10085 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10086 }
10087 {
10088 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10089 if (PyErr_Occurred()) SWIG_fail;
10090 }
10091 resultobj = SWIG_Py_Void();
10092 return resultobj;
10093 fail:
10094 return NULL;
10095 }
10096
10097
10098 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10099 PyObject *resultobj = 0;
10100 wxRect2D *arg1 = (wxRect2D *) 0 ;
10101 wxPoint2D result;
10102 void *argp1 = 0 ;
10103 int res1 = 0 ;
10104 PyObject *swig_obj[1] ;
10105
10106 if (!args) SWIG_fail;
10107 swig_obj[0] = args;
10108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10109 if (!SWIG_IsOK(res1)) {
10110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10111 }
10112 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10113 {
10114 result = ((wxRect2D const *)arg1)->GetRightBottom();
10115 if (PyErr_Occurred()) SWIG_fail;
10116 }
10117 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10118 return resultobj;
10119 fail:
10120 return NULL;
10121 }
10122
10123
10124 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10125 PyObject *resultobj = 0;
10126 wxRect2D *arg1 = (wxRect2D *) 0 ;
10127 wxPoint2D *arg2 = 0 ;
10128 void *argp1 = 0 ;
10129 int res1 = 0 ;
10130 wxPoint2D temp2 ;
10131 PyObject * obj0 = 0 ;
10132 PyObject * obj1 = 0 ;
10133 char * kwnames[] = {
10134 (char *) "self",(char *) "pt", NULL
10135 };
10136
10137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10139 if (!SWIG_IsOK(res1)) {
10140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10141 }
10142 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10143 {
10144 arg2 = &temp2;
10145 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10146 }
10147 {
10148 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10149 if (PyErr_Occurred()) SWIG_fail;
10150 }
10151 resultobj = SWIG_Py_Void();
10152 return resultobj;
10153 fail:
10154 return NULL;
10155 }
10156
10157
10158 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10159 PyObject *resultobj = 0;
10160 wxRect2D *arg1 = (wxRect2D *) 0 ;
10161 wxPoint2D *arg2 = 0 ;
10162 void *argp1 = 0 ;
10163 int res1 = 0 ;
10164 wxPoint2D temp2 ;
10165 PyObject * obj0 = 0 ;
10166 PyObject * obj1 = 0 ;
10167 char * kwnames[] = {
10168 (char *) "self",(char *) "pt", NULL
10169 };
10170
10171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10173 if (!SWIG_IsOK(res1)) {
10174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10175 }
10176 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10177 {
10178 arg2 = &temp2;
10179 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10180 }
10181 {
10182 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10183 if (PyErr_Occurred()) SWIG_fail;
10184 }
10185 resultobj = SWIG_Py_Void();
10186 return resultobj;
10187 fail:
10188 return NULL;
10189 }
10190
10191
10192 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10193 PyObject *resultobj = 0;
10194 wxRect2D *arg1 = (wxRect2D *) 0 ;
10195 wxPoint2D result;
10196 void *argp1 = 0 ;
10197 int res1 = 0 ;
10198 PyObject *swig_obj[1] ;
10199
10200 if (!args) SWIG_fail;
10201 swig_obj[0] = args;
10202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10203 if (!SWIG_IsOK(res1)) {
10204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10205 }
10206 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10207 {
10208 result = ((wxRect2D const *)arg1)->GetCentre();
10209 if (PyErr_Occurred()) SWIG_fail;
10210 }
10211 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10212 return resultobj;
10213 fail:
10214 return NULL;
10215 }
10216
10217
10218 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10219 PyObject *resultobj = 0;
10220 wxRect2D *arg1 = (wxRect2D *) 0 ;
10221 wxPoint2D *arg2 = 0 ;
10222 void *argp1 = 0 ;
10223 int res1 = 0 ;
10224 wxPoint2D temp2 ;
10225 PyObject * obj0 = 0 ;
10226 PyObject * obj1 = 0 ;
10227 char * kwnames[] = {
10228 (char *) "self",(char *) "pt", NULL
10229 };
10230
10231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10233 if (!SWIG_IsOK(res1)) {
10234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10235 }
10236 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10237 {
10238 arg2 = &temp2;
10239 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10240 }
10241 {
10242 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10243 if (PyErr_Occurred()) SWIG_fail;
10244 }
10245 resultobj = SWIG_Py_Void();
10246 return resultobj;
10247 fail:
10248 return NULL;
10249 }
10250
10251
10252 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10253 PyObject *resultobj = 0;
10254 wxRect2D *arg1 = (wxRect2D *) 0 ;
10255 wxPoint2D *arg2 = 0 ;
10256 void *argp1 = 0 ;
10257 int res1 = 0 ;
10258 wxPoint2D temp2 ;
10259 PyObject * obj0 = 0 ;
10260 PyObject * obj1 = 0 ;
10261 char * kwnames[] = {
10262 (char *) "self",(char *) "pt", NULL
10263 };
10264
10265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10267 if (!SWIG_IsOK(res1)) {
10268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10269 }
10270 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10271 {
10272 arg2 = &temp2;
10273 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10274 }
10275 {
10276 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10277 if (PyErr_Occurred()) SWIG_fail;
10278 }
10279 resultobj = SWIG_Py_Void();
10280 return resultobj;
10281 fail:
10282 return NULL;
10283 }
10284
10285
10286 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10287 PyObject *resultobj = 0;
10288 wxRect2D *arg1 = (wxRect2D *) 0 ;
10289 wxPoint2D *arg2 = 0 ;
10290 wxOutCode result;
10291 void *argp1 = 0 ;
10292 int res1 = 0 ;
10293 wxPoint2D temp2 ;
10294 PyObject * obj0 = 0 ;
10295 PyObject * obj1 = 0 ;
10296 char * kwnames[] = {
10297 (char *) "self",(char *) "pt", NULL
10298 };
10299
10300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10302 if (!SWIG_IsOK(res1)) {
10303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10304 }
10305 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10306 {
10307 arg2 = &temp2;
10308 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10309 }
10310 {
10311 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10312 if (PyErr_Occurred()) SWIG_fail;
10313 }
10314 resultobj = SWIG_From_int(static_cast< int >(result));
10315 return resultobj;
10316 fail:
10317 return NULL;
10318 }
10319
10320
10321 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10322 PyObject *resultobj = 0;
10323 wxRect2D *arg1 = (wxRect2D *) 0 ;
10324 wxPoint2D *arg2 = 0 ;
10325 bool result;
10326 void *argp1 = 0 ;
10327 int res1 = 0 ;
10328 wxPoint2D temp2 ;
10329 PyObject * obj0 = 0 ;
10330 PyObject * obj1 = 0 ;
10331 char * kwnames[] = {
10332 (char *) "self",(char *) "pt", NULL
10333 };
10334
10335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10337 if (!SWIG_IsOK(res1)) {
10338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10339 }
10340 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10341 {
10342 arg2 = &temp2;
10343 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10344 }
10345 {
10346 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10347 if (PyErr_Occurred()) SWIG_fail;
10348 }
10349 {
10350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10351 }
10352 return resultobj;
10353 fail:
10354 return NULL;
10355 }
10356
10357
10358 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10359 PyObject *resultobj = 0;
10360 wxRect2D *arg1 = (wxRect2D *) 0 ;
10361 wxRect2D *arg2 = 0 ;
10362 bool result;
10363 void *argp1 = 0 ;
10364 int res1 = 0 ;
10365 wxRect2D temp2 ;
10366 PyObject * obj0 = 0 ;
10367 PyObject * obj1 = 0 ;
10368 char * kwnames[] = {
10369 (char *) "self",(char *) "rect", NULL
10370 };
10371
10372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10374 if (!SWIG_IsOK(res1)) {
10375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10376 }
10377 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10378 {
10379 arg2 = &temp2;
10380 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10381 }
10382 {
10383 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10384 if (PyErr_Occurred()) SWIG_fail;
10385 }
10386 {
10387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10388 }
10389 return resultobj;
10390 fail:
10391 return NULL;
10392 }
10393
10394
10395 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10396 PyObject *resultobj = 0;
10397 wxRect2D *arg1 = (wxRect2D *) 0 ;
10398 bool result;
10399 void *argp1 = 0 ;
10400 int res1 = 0 ;
10401 PyObject *swig_obj[1] ;
10402
10403 if (!args) SWIG_fail;
10404 swig_obj[0] = args;
10405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10406 if (!SWIG_IsOK(res1)) {
10407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10408 }
10409 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10410 {
10411 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10412 if (PyErr_Occurred()) SWIG_fail;
10413 }
10414 {
10415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10416 }
10417 return resultobj;
10418 fail:
10419 return NULL;
10420 }
10421
10422
10423 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10424 PyObject *resultobj = 0;
10425 wxRect2D *arg1 = (wxRect2D *) 0 ;
10426 wxRect2D *arg2 = 0 ;
10427 bool result;
10428 void *argp1 = 0 ;
10429 int res1 = 0 ;
10430 wxRect2D temp2 ;
10431 PyObject * obj0 = 0 ;
10432 PyObject * obj1 = 0 ;
10433 char * kwnames[] = {
10434 (char *) "self",(char *) "rect", NULL
10435 };
10436
10437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10439 if (!SWIG_IsOK(res1)) {
10440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10441 }
10442 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10443 {
10444 arg2 = &temp2;
10445 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10446 }
10447 {
10448 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10449 if (PyErr_Occurred()) SWIG_fail;
10450 }
10451 {
10452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10453 }
10454 return resultobj;
10455 fail:
10456 return NULL;
10457 }
10458
10459
10460 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10461 PyObject *resultobj = 0;
10462 wxRect2D *arg1 = (wxRect2D *) 0 ;
10463 wxDouble arg2 ;
10464 wxDouble arg3 ;
10465 void *argp1 = 0 ;
10466 int res1 = 0 ;
10467 void *argp2 ;
10468 int res2 = 0 ;
10469 void *argp3 ;
10470 int res3 = 0 ;
10471
10472 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10474 if (!SWIG_IsOK(res1)) {
10475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10476 }
10477 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10478 {
10479 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10480 if (!SWIG_IsOK(res2)) {
10481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10482 }
10483 if (!argp2) {
10484 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10485 } else {
10486 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10487 arg2 = *temp;
10488 if (SWIG_IsNewObj(res2)) delete temp;
10489 }
10490 }
10491 {
10492 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10493 if (!SWIG_IsOK(res3)) {
10494 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10495 }
10496 if (!argp3) {
10497 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10498 } else {
10499 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10500 arg3 = *temp;
10501 if (SWIG_IsNewObj(res3)) delete temp;
10502 }
10503 }
10504 {
10505 (arg1)->Inset(arg2,arg3);
10506 if (PyErr_Occurred()) SWIG_fail;
10507 }
10508 resultobj = SWIG_Py_Void();
10509 return resultobj;
10510 fail:
10511 return NULL;
10512 }
10513
10514
10515 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10516 PyObject *resultobj = 0;
10517 wxRect2D *arg1 = (wxRect2D *) 0 ;
10518 wxDouble arg2 ;
10519 wxDouble arg3 ;
10520 wxDouble arg4 ;
10521 wxDouble arg5 ;
10522 void *argp1 = 0 ;
10523 int res1 = 0 ;
10524 void *argp2 ;
10525 int res2 = 0 ;
10526 void *argp3 ;
10527 int res3 = 0 ;
10528 void *argp4 ;
10529 int res4 = 0 ;
10530 void *argp5 ;
10531 int res5 = 0 ;
10532
10533 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10535 if (!SWIG_IsOK(res1)) {
10536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10537 }
10538 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10539 {
10540 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10541 if (!SWIG_IsOK(res2)) {
10542 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10543 }
10544 if (!argp2) {
10545 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10546 } else {
10547 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10548 arg2 = *temp;
10549 if (SWIG_IsNewObj(res2)) delete temp;
10550 }
10551 }
10552 {
10553 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10554 if (!SWIG_IsOK(res3)) {
10555 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10556 }
10557 if (!argp3) {
10558 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10559 } else {
10560 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10561 arg3 = *temp;
10562 if (SWIG_IsNewObj(res3)) delete temp;
10563 }
10564 }
10565 {
10566 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10567 if (!SWIG_IsOK(res4)) {
10568 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10569 }
10570 if (!argp4) {
10571 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10572 } else {
10573 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10574 arg4 = *temp;
10575 if (SWIG_IsNewObj(res4)) delete temp;
10576 }
10577 }
10578 {
10579 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10580 if (!SWIG_IsOK(res5)) {
10581 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10582 }
10583 if (!argp5) {
10584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10585 } else {
10586 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10587 arg5 = *temp;
10588 if (SWIG_IsNewObj(res5)) delete temp;
10589 }
10590 }
10591 {
10592 (arg1)->Inset(arg2,arg3,arg4,arg5);
10593 if (PyErr_Occurred()) SWIG_fail;
10594 }
10595 resultobj = SWIG_Py_Void();
10596 return resultobj;
10597 fail:
10598 return NULL;
10599 }
10600
10601
10602 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10603 int argc;
10604 PyObject *argv[6];
10605
10606 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10607 --argc;
10608 if (argc == 3) {
10609 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10610 }
10611 if (argc == 5) {
10612 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10613 }
10614
10615 fail:
10616 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10617 return NULL;
10618 }
10619
10620
10621 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10622 PyObject *resultobj = 0;
10623 wxRect2D *arg1 = (wxRect2D *) 0 ;
10624 wxPoint2D *arg2 = 0 ;
10625 void *argp1 = 0 ;
10626 int res1 = 0 ;
10627 wxPoint2D temp2 ;
10628 PyObject * obj0 = 0 ;
10629 PyObject * obj1 = 0 ;
10630 char * kwnames[] = {
10631 (char *) "self",(char *) "pt", NULL
10632 };
10633
10634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10636 if (!SWIG_IsOK(res1)) {
10637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10638 }
10639 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10640 {
10641 arg2 = &temp2;
10642 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10643 }
10644 {
10645 (arg1)->Offset((wxPoint2D const &)*arg2);
10646 if (PyErr_Occurred()) SWIG_fail;
10647 }
10648 resultobj = SWIG_Py_Void();
10649 return resultobj;
10650 fail:
10651 return NULL;
10652 }
10653
10654
10655 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10656 PyObject *resultobj = 0;
10657 wxRect2D *arg1 = (wxRect2D *) 0 ;
10658 wxRect2D *arg2 = 0 ;
10659 void *argp1 = 0 ;
10660 int res1 = 0 ;
10661 wxRect2D temp2 ;
10662 PyObject * obj0 = 0 ;
10663 PyObject * obj1 = 0 ;
10664 char * kwnames[] = {
10665 (char *) "self",(char *) "rect", NULL
10666 };
10667
10668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10670 if (!SWIG_IsOK(res1)) {
10671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10672 }
10673 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10674 {
10675 arg2 = &temp2;
10676 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10677 }
10678 {
10679 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10680 if (PyErr_Occurred()) SWIG_fail;
10681 }
10682 resultobj = SWIG_Py_Void();
10683 return resultobj;
10684 fail:
10685 return NULL;
10686 }
10687
10688
10689 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10690 PyObject *resultobj = 0;
10691 wxRect2D *arg1 = (wxRect2D *) 0 ;
10692 int arg2 ;
10693 int arg3 ;
10694 wxPoint2D result;
10695 void *argp1 = 0 ;
10696 int res1 = 0 ;
10697 int val2 ;
10698 int ecode2 = 0 ;
10699 int val3 ;
10700 int ecode3 = 0 ;
10701 PyObject * obj0 = 0 ;
10702 PyObject * obj1 = 0 ;
10703 PyObject * obj2 = 0 ;
10704 char * kwnames[] = {
10705 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10706 };
10707
10708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10710 if (!SWIG_IsOK(res1)) {
10711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10712 }
10713 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10714 ecode2 = SWIG_AsVal_int(obj1, &val2);
10715 if (!SWIG_IsOK(ecode2)) {
10716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10717 }
10718 arg2 = static_cast< int >(val2);
10719 ecode3 = SWIG_AsVal_int(obj2, &val3);
10720 if (!SWIG_IsOK(ecode3)) {
10721 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10722 }
10723 arg3 = static_cast< int >(val3);
10724 {
10725 result = (arg1)->Interpolate(arg2,arg3);
10726 if (PyErr_Occurred()) SWIG_fail;
10727 }
10728 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10729 return resultobj;
10730 fail:
10731 return NULL;
10732 }
10733
10734
10735 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10736 PyObject *resultobj = 0;
10737 wxRect2D *arg1 = (wxRect2D *) 0 ;
10738 wxRect2D *arg2 = 0 ;
10739 void *argp1 = 0 ;
10740 int res1 = 0 ;
10741 wxRect2D temp2 ;
10742 PyObject * obj0 = 0 ;
10743 PyObject * obj1 = 0 ;
10744 char * kwnames[] = {
10745 (char *) "self",(char *) "otherRect", NULL
10746 };
10747
10748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10750 if (!SWIG_IsOK(res1)) {
10751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10752 }
10753 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10754 {
10755 arg2 = &temp2;
10756 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10757 }
10758 {
10759 (arg1)->Intersect((wxRect2D const &)*arg2);
10760 if (PyErr_Occurred()) SWIG_fail;
10761 }
10762 resultobj = SWIG_Py_Void();
10763 return resultobj;
10764 fail:
10765 return NULL;
10766 }
10767
10768
10769 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10770 PyObject *resultobj = 0;
10771 wxRect2D *arg1 = (wxRect2D *) 0 ;
10772 wxRect2D *arg2 = 0 ;
10773 wxRect2D result;
10774 void *argp1 = 0 ;
10775 int res1 = 0 ;
10776 wxRect2D temp2 ;
10777 PyObject * obj0 = 0 ;
10778 PyObject * obj1 = 0 ;
10779 char * kwnames[] = {
10780 (char *) "self",(char *) "otherRect", NULL
10781 };
10782
10783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10785 if (!SWIG_IsOK(res1)) {
10786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10787 }
10788 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10789 {
10790 arg2 = &temp2;
10791 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10792 }
10793 {
10794 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10795 if (PyErr_Occurred()) SWIG_fail;
10796 }
10797 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10798 return resultobj;
10799 fail:
10800 return NULL;
10801 }
10802
10803
10804 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10805 PyObject *resultobj = 0;
10806 wxRect2D *arg1 = (wxRect2D *) 0 ;
10807 wxRect2D *arg2 = 0 ;
10808 bool result;
10809 void *argp1 = 0 ;
10810 int res1 = 0 ;
10811 wxRect2D temp2 ;
10812 PyObject * obj0 = 0 ;
10813 PyObject * obj1 = 0 ;
10814 char * kwnames[] = {
10815 (char *) "self",(char *) "rect", NULL
10816 };
10817
10818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10820 if (!SWIG_IsOK(res1)) {
10821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10822 }
10823 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10824 {
10825 arg2 = &temp2;
10826 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10827 }
10828 {
10829 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10830 if (PyErr_Occurred()) SWIG_fail;
10831 }
10832 {
10833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10834 }
10835 return resultobj;
10836 fail:
10837 return NULL;
10838 }
10839
10840
10841 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10842 PyObject *resultobj = 0;
10843 wxRect2D *arg1 = (wxRect2D *) 0 ;
10844 wxRect2D *arg2 = 0 ;
10845 void *argp1 = 0 ;
10846 int res1 = 0 ;
10847 wxRect2D temp2 ;
10848 PyObject * obj0 = 0 ;
10849 PyObject * obj1 = 0 ;
10850 char * kwnames[] = {
10851 (char *) "self",(char *) "otherRect", NULL
10852 };
10853
10854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10856 if (!SWIG_IsOK(res1)) {
10857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10858 }
10859 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10860 {
10861 arg2 = &temp2;
10862 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10863 }
10864 {
10865 (arg1)->Union((wxRect2D const &)*arg2);
10866 if (PyErr_Occurred()) SWIG_fail;
10867 }
10868 resultobj = SWIG_Py_Void();
10869 return resultobj;
10870 fail:
10871 return NULL;
10872 }
10873
10874
10875 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10876 PyObject *resultobj = 0;
10877 wxRect2D *arg1 = (wxRect2D *) 0 ;
10878 wxRect2D *arg2 = 0 ;
10879 wxRect2D result;
10880 void *argp1 = 0 ;
10881 int res1 = 0 ;
10882 wxRect2D temp2 ;
10883 PyObject * obj0 = 0 ;
10884 PyObject * obj1 = 0 ;
10885 char * kwnames[] = {
10886 (char *) "self",(char *) "otherRect", NULL
10887 };
10888
10889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10891 if (!SWIG_IsOK(res1)) {
10892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10893 }
10894 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10895 {
10896 arg2 = &temp2;
10897 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10898 }
10899 {
10900 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10901 if (PyErr_Occurred()) SWIG_fail;
10902 }
10903 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10904 return resultobj;
10905 fail:
10906 return NULL;
10907 }
10908
10909
10910 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10911 PyObject *resultobj = 0;
10912 wxRect2D *arg1 = (wxRect2D *) 0 ;
10913 wxDouble arg2 ;
10914 void *argp1 = 0 ;
10915 int res1 = 0 ;
10916 void *argp2 ;
10917 int res2 = 0 ;
10918
10919 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10921 if (!SWIG_IsOK(res1)) {
10922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10923 }
10924 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10925 {
10926 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10927 if (!SWIG_IsOK(res2)) {
10928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10929 }
10930 if (!argp2) {
10931 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10932 } else {
10933 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10934 arg2 = *temp;
10935 if (SWIG_IsNewObj(res2)) delete temp;
10936 }
10937 }
10938 {
10939 (arg1)->Scale(arg2);
10940 if (PyErr_Occurred()) SWIG_fail;
10941 }
10942 resultobj = SWIG_Py_Void();
10943 return resultobj;
10944 fail:
10945 return NULL;
10946 }
10947
10948
10949 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10950 PyObject *resultobj = 0;
10951 wxRect2D *arg1 = (wxRect2D *) 0 ;
10952 int arg2 ;
10953 int arg3 ;
10954 void *argp1 = 0 ;
10955 int res1 = 0 ;
10956 int val2 ;
10957 int ecode2 = 0 ;
10958 int val3 ;
10959 int ecode3 = 0 ;
10960
10961 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10963 if (!SWIG_IsOK(res1)) {
10964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10965 }
10966 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10967 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10968 if (!SWIG_IsOK(ecode2)) {
10969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10970 }
10971 arg2 = static_cast< int >(val2);
10972 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10973 if (!SWIG_IsOK(ecode3)) {
10974 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10975 }
10976 arg3 = static_cast< int >(val3);
10977 {
10978 (arg1)->Scale(arg2,arg3);
10979 if (PyErr_Occurred()) SWIG_fail;
10980 }
10981 resultobj = SWIG_Py_Void();
10982 return resultobj;
10983 fail:
10984 return NULL;
10985 }
10986
10987
10988 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
10989 int argc;
10990 PyObject *argv[4];
10991
10992 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
10993 --argc;
10994 if (argc == 2) {
10995 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
10996 }
10997 if (argc == 3) {
10998 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
10999 }
11000
11001 fail:
11002 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
11003 return NULL;
11004 }
11005
11006
11007 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11008 PyObject *resultobj = 0;
11009 wxRect2D *arg1 = (wxRect2D *) 0 ;
11010 PyObject *arg2 = (PyObject *) 0 ;
11011 bool result;
11012 void *argp1 = 0 ;
11013 int res1 = 0 ;
11014 PyObject * obj0 = 0 ;
11015 PyObject * obj1 = 0 ;
11016 char * kwnames[] = {
11017 (char *) "self",(char *) "other", NULL
11018 };
11019
11020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
11021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11022 if (!SWIG_IsOK(res1)) {
11023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11024 }
11025 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11026 arg2 = obj1;
11027 {
11028 result = (bool)wxRect2D___eq__(arg1,arg2);
11029 if (PyErr_Occurred()) SWIG_fail;
11030 }
11031 {
11032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11033 }
11034 return resultobj;
11035 fail:
11036 return NULL;
11037 }
11038
11039
11040 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11041 PyObject *resultobj = 0;
11042 wxRect2D *arg1 = (wxRect2D *) 0 ;
11043 PyObject *arg2 = (PyObject *) 0 ;
11044 bool result;
11045 void *argp1 = 0 ;
11046 int res1 = 0 ;
11047 PyObject * obj0 = 0 ;
11048 PyObject * obj1 = 0 ;
11049 char * kwnames[] = {
11050 (char *) "self",(char *) "other", NULL
11051 };
11052
11053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
11054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11055 if (!SWIG_IsOK(res1)) {
11056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11057 }
11058 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11059 arg2 = obj1;
11060 {
11061 result = (bool)wxRect2D___ne__(arg1,arg2);
11062 if (PyErr_Occurred()) SWIG_fail;
11063 }
11064 {
11065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11066 }
11067 return resultobj;
11068 fail:
11069 return NULL;
11070 }
11071
11072
11073 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11074 PyObject *resultobj = 0;
11075 wxRect2D *arg1 = (wxRect2D *) 0 ;
11076 wxDouble arg2 ;
11077 void *argp1 = 0 ;
11078 int res1 = 0 ;
11079 void *argp2 ;
11080 int res2 = 0 ;
11081 PyObject *swig_obj[2] ;
11082
11083 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11085 if (!SWIG_IsOK(res1)) {
11086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11087 }
11088 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11089 {
11090 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11091 if (!SWIG_IsOK(res2)) {
11092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11093 }
11094 if (!argp2) {
11095 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11096 } else {
11097 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11098 arg2 = *temp;
11099 if (SWIG_IsNewObj(res2)) delete temp;
11100 }
11101 }
11102 if (arg1) (arg1)->m_x = arg2;
11103
11104 resultobj = SWIG_Py_Void();
11105 return resultobj;
11106 fail:
11107 return NULL;
11108 }
11109
11110
11111 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11112 PyObject *resultobj = 0;
11113 wxRect2D *arg1 = (wxRect2D *) 0 ;
11114 wxDouble result;
11115 void *argp1 = 0 ;
11116 int res1 = 0 ;
11117 PyObject *swig_obj[1] ;
11118
11119 if (!args) SWIG_fail;
11120 swig_obj[0] = args;
11121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11122 if (!SWIG_IsOK(res1)) {
11123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11124 }
11125 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11126 result = ((arg1)->m_x);
11127 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11128 return resultobj;
11129 fail:
11130 return NULL;
11131 }
11132
11133
11134 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11135 PyObject *resultobj = 0;
11136 wxRect2D *arg1 = (wxRect2D *) 0 ;
11137 wxDouble arg2 ;
11138 void *argp1 = 0 ;
11139 int res1 = 0 ;
11140 void *argp2 ;
11141 int res2 = 0 ;
11142 PyObject *swig_obj[2] ;
11143
11144 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11146 if (!SWIG_IsOK(res1)) {
11147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11148 }
11149 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11150 {
11151 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11152 if (!SWIG_IsOK(res2)) {
11153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11154 }
11155 if (!argp2) {
11156 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11157 } else {
11158 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11159 arg2 = *temp;
11160 if (SWIG_IsNewObj(res2)) delete temp;
11161 }
11162 }
11163 if (arg1) (arg1)->m_y = arg2;
11164
11165 resultobj = SWIG_Py_Void();
11166 return resultobj;
11167 fail:
11168 return NULL;
11169 }
11170
11171
11172 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11173 PyObject *resultobj = 0;
11174 wxRect2D *arg1 = (wxRect2D *) 0 ;
11175 wxDouble result;
11176 void *argp1 = 0 ;
11177 int res1 = 0 ;
11178 PyObject *swig_obj[1] ;
11179
11180 if (!args) SWIG_fail;
11181 swig_obj[0] = args;
11182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11183 if (!SWIG_IsOK(res1)) {
11184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11185 }
11186 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11187 result = ((arg1)->m_y);
11188 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11189 return resultobj;
11190 fail:
11191 return NULL;
11192 }
11193
11194
11195 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11196 PyObject *resultobj = 0;
11197 wxRect2D *arg1 = (wxRect2D *) 0 ;
11198 wxDouble arg2 ;
11199 void *argp1 = 0 ;
11200 int res1 = 0 ;
11201 void *argp2 ;
11202 int res2 = 0 ;
11203 PyObject *swig_obj[2] ;
11204
11205 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11207 if (!SWIG_IsOK(res1)) {
11208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11209 }
11210 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11211 {
11212 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11213 if (!SWIG_IsOK(res2)) {
11214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11215 }
11216 if (!argp2) {
11217 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11218 } else {
11219 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11220 arg2 = *temp;
11221 if (SWIG_IsNewObj(res2)) delete temp;
11222 }
11223 }
11224 if (arg1) (arg1)->m_width = arg2;
11225
11226 resultobj = SWIG_Py_Void();
11227 return resultobj;
11228 fail:
11229 return NULL;
11230 }
11231
11232
11233 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11234 PyObject *resultobj = 0;
11235 wxRect2D *arg1 = (wxRect2D *) 0 ;
11236 wxDouble result;
11237 void *argp1 = 0 ;
11238 int res1 = 0 ;
11239 PyObject *swig_obj[1] ;
11240
11241 if (!args) SWIG_fail;
11242 swig_obj[0] = args;
11243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11244 if (!SWIG_IsOK(res1)) {
11245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11246 }
11247 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11248 result = ((arg1)->m_width);
11249 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11250 return resultobj;
11251 fail:
11252 return NULL;
11253 }
11254
11255
11256 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11257 PyObject *resultobj = 0;
11258 wxRect2D *arg1 = (wxRect2D *) 0 ;
11259 wxDouble arg2 ;
11260 void *argp1 = 0 ;
11261 int res1 = 0 ;
11262 void *argp2 ;
11263 int res2 = 0 ;
11264 PyObject *swig_obj[2] ;
11265
11266 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11268 if (!SWIG_IsOK(res1)) {
11269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11270 }
11271 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11272 {
11273 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11274 if (!SWIG_IsOK(res2)) {
11275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11276 }
11277 if (!argp2) {
11278 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11279 } else {
11280 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11281 arg2 = *temp;
11282 if (SWIG_IsNewObj(res2)) delete temp;
11283 }
11284 }
11285 if (arg1) (arg1)->m_height = arg2;
11286
11287 resultobj = SWIG_Py_Void();
11288 return resultobj;
11289 fail:
11290 return NULL;
11291 }
11292
11293
11294 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11295 PyObject *resultobj = 0;
11296 wxRect2D *arg1 = (wxRect2D *) 0 ;
11297 wxDouble result;
11298 void *argp1 = 0 ;
11299 int res1 = 0 ;
11300 PyObject *swig_obj[1] ;
11301
11302 if (!args) SWIG_fail;
11303 swig_obj[0] = args;
11304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11305 if (!SWIG_IsOK(res1)) {
11306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11307 }
11308 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11309 result = ((arg1)->m_height);
11310 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11311 return resultobj;
11312 fail:
11313 return NULL;
11314 }
11315
11316
11317 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11318 PyObject *resultobj = 0;
11319 wxRect2D *arg1 = (wxRect2D *) 0 ;
11320 wxDouble arg2 = (wxDouble) 0 ;
11321 wxDouble arg3 = (wxDouble) 0 ;
11322 wxDouble arg4 = (wxDouble) 0 ;
11323 wxDouble arg5 = (wxDouble) 0 ;
11324 void *argp1 = 0 ;
11325 int res1 = 0 ;
11326 void *argp2 ;
11327 int res2 = 0 ;
11328 void *argp3 ;
11329 int res3 = 0 ;
11330 void *argp4 ;
11331 int res4 = 0 ;
11332 void *argp5 ;
11333 int res5 = 0 ;
11334 PyObject * obj0 = 0 ;
11335 PyObject * obj1 = 0 ;
11336 PyObject * obj2 = 0 ;
11337 PyObject * obj3 = 0 ;
11338 PyObject * obj4 = 0 ;
11339 char * kwnames[] = {
11340 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11341 };
11342
11343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11345 if (!SWIG_IsOK(res1)) {
11346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11347 }
11348 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11349 if (obj1) {
11350 {
11351 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11352 if (!SWIG_IsOK(res2)) {
11353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11354 }
11355 if (!argp2) {
11356 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11357 } else {
11358 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11359 arg2 = *temp;
11360 if (SWIG_IsNewObj(res2)) delete temp;
11361 }
11362 }
11363 }
11364 if (obj2) {
11365 {
11366 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11367 if (!SWIG_IsOK(res3)) {
11368 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11369 }
11370 if (!argp3) {
11371 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11372 } else {
11373 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11374 arg3 = *temp;
11375 if (SWIG_IsNewObj(res3)) delete temp;
11376 }
11377 }
11378 }
11379 if (obj3) {
11380 {
11381 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11382 if (!SWIG_IsOK(res4)) {
11383 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11384 }
11385 if (!argp4) {
11386 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11387 } else {
11388 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11389 arg4 = *temp;
11390 if (SWIG_IsNewObj(res4)) delete temp;
11391 }
11392 }
11393 }
11394 if (obj4) {
11395 {
11396 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11397 if (!SWIG_IsOK(res5)) {
11398 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11399 }
11400 if (!argp5) {
11401 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11402 } else {
11403 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11404 arg5 = *temp;
11405 if (SWIG_IsNewObj(res5)) delete temp;
11406 }
11407 }
11408 }
11409 {
11410 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11411 if (PyErr_Occurred()) SWIG_fail;
11412 }
11413 resultobj = SWIG_Py_Void();
11414 return resultobj;
11415 fail:
11416 return NULL;
11417 }
11418
11419
11420 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11421 PyObject *resultobj = 0;
11422 wxRect2D *arg1 = (wxRect2D *) 0 ;
11423 PyObject *result = 0 ;
11424 void *argp1 = 0 ;
11425 int res1 = 0 ;
11426 PyObject *swig_obj[1] ;
11427
11428 if (!args) SWIG_fail;
11429 swig_obj[0] = args;
11430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11431 if (!SWIG_IsOK(res1)) {
11432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11433 }
11434 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11435 {
11436 result = (PyObject *)wxRect2D_Get(arg1);
11437 if (PyErr_Occurred()) SWIG_fail;
11438 }
11439 resultobj = result;
11440 return resultobj;
11441 fail:
11442 return NULL;
11443 }
11444
11445
11446 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11447 PyObject *obj;
11448 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11449 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11450 return SWIG_Py_Void();
11451 }
11452
11453 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11454 return SWIG_Python_InitShadowInstance(args);
11455 }
11456
11457 SWIGINTERN int DefaultPosition_set(PyObject *) {
11458 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11459 return 1;
11460 }
11461
11462
11463 SWIGINTERN PyObject *DefaultPosition_get(void) {
11464 PyObject *pyobj = 0;
11465
11466 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11467 return pyobj;
11468 }
11469
11470
11471 SWIGINTERN int DefaultSize_set(PyObject *) {
11472 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11473 return 1;
11474 }
11475
11476
11477 SWIGINTERN PyObject *DefaultSize_get(void) {
11478 PyObject *pyobj = 0;
11479
11480 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11481 return pyobj;
11482 }
11483
11484
11485 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11486 PyObject *resultobj = 0;
11487 PyObject *arg1 = (PyObject *) 0 ;
11488 wxPyInputStream *result = 0 ;
11489 PyObject * obj0 = 0 ;
11490 char * kwnames[] = {
11491 (char *) "p", NULL
11492 };
11493
11494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11495 arg1 = obj0;
11496 {
11497 PyThreadState* __tstate = wxPyBeginAllowThreads();
11498 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11499 wxPyEndAllowThreads(__tstate);
11500 if (PyErr_Occurred()) SWIG_fail;
11501 }
11502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11503 return resultobj;
11504 fail:
11505 return NULL;
11506 }
11507
11508
11509 SWIGINTERN PyObject *_wrap_delete_InputStream(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, SWIG_POINTER_DISOWN | 0 );
11519 if (!SWIG_IsOK(res1)) {
11520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11521 }
11522 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11523 {
11524 PyThreadState* __tstate = wxPyBeginAllowThreads();
11525 delete arg1;
11526
11527 wxPyEndAllowThreads(__tstate);
11528 if (PyErr_Occurred()) SWIG_fail;
11529 }
11530 resultobj = SWIG_Py_Void();
11531 return resultobj;
11532 fail:
11533 return NULL;
11534 }
11535
11536
11537 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11538 PyObject *resultobj = 0;
11539 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
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_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11549 }
11550 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11551 {
11552 PyThreadState* __tstate = wxPyBeginAllowThreads();
11553 (arg1)->close();
11554 wxPyEndAllowThreads(__tstate);
11555 if (PyErr_Occurred()) SWIG_fail;
11556 }
11557 resultobj = SWIG_Py_Void();
11558 return resultobj;
11559 fail:
11560 return NULL;
11561 }
11562
11563
11564 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11565 PyObject *resultobj = 0;
11566 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11567 void *argp1 = 0 ;
11568 int res1 = 0 ;
11569 PyObject *swig_obj[1] ;
11570
11571 if (!args) SWIG_fail;
11572 swig_obj[0] = args;
11573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11574 if (!SWIG_IsOK(res1)) {
11575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11576 }
11577 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11578 {
11579 PyThreadState* __tstate = wxPyBeginAllowThreads();
11580 (arg1)->flush();
11581 wxPyEndAllowThreads(__tstate);
11582 if (PyErr_Occurred()) SWIG_fail;
11583 }
11584 resultobj = SWIG_Py_Void();
11585 return resultobj;
11586 fail:
11587 return NULL;
11588 }
11589
11590
11591 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11592 PyObject *resultobj = 0;
11593 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11594 bool result;
11595 void *argp1 = 0 ;
11596 int res1 = 0 ;
11597 PyObject *swig_obj[1] ;
11598
11599 if (!args) SWIG_fail;
11600 swig_obj[0] = args;
11601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11602 if (!SWIG_IsOK(res1)) {
11603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11604 }
11605 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11606 {
11607 PyThreadState* __tstate = wxPyBeginAllowThreads();
11608 result = (bool)(arg1)->eof();
11609 wxPyEndAllowThreads(__tstate);
11610 if (PyErr_Occurred()) SWIG_fail;
11611 }
11612 {
11613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11614 }
11615 return resultobj;
11616 fail:
11617 return NULL;
11618 }
11619
11620
11621 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11622 PyObject *resultobj = 0;
11623 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11624 int arg2 = (int) -1 ;
11625 PyObject *result = 0 ;
11626 void *argp1 = 0 ;
11627 int res1 = 0 ;
11628 int val2 ;
11629 int ecode2 = 0 ;
11630 PyObject * obj0 = 0 ;
11631 PyObject * obj1 = 0 ;
11632 char * kwnames[] = {
11633 (char *) "self",(char *) "size", NULL
11634 };
11635
11636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11638 if (!SWIG_IsOK(res1)) {
11639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11640 }
11641 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11642 if (obj1) {
11643 ecode2 = SWIG_AsVal_int(obj1, &val2);
11644 if (!SWIG_IsOK(ecode2)) {
11645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11646 }
11647 arg2 = static_cast< int >(val2);
11648 }
11649 {
11650 PyThreadState* __tstate = wxPyBeginAllowThreads();
11651 result = (PyObject *)(arg1)->read(arg2);
11652 wxPyEndAllowThreads(__tstate);
11653 if (PyErr_Occurred()) SWIG_fail;
11654 }
11655 resultobj = result;
11656 return resultobj;
11657 fail:
11658 return NULL;
11659 }
11660
11661
11662 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11663 PyObject *resultobj = 0;
11664 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11665 int arg2 = (int) -1 ;
11666 PyObject *result = 0 ;
11667 void *argp1 = 0 ;
11668 int res1 = 0 ;
11669 int val2 ;
11670 int ecode2 = 0 ;
11671 PyObject * obj0 = 0 ;
11672 PyObject * obj1 = 0 ;
11673 char * kwnames[] = {
11674 (char *) "self",(char *) "size", NULL
11675 };
11676
11677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11679 if (!SWIG_IsOK(res1)) {
11680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11681 }
11682 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11683 if (obj1) {
11684 ecode2 = SWIG_AsVal_int(obj1, &val2);
11685 if (!SWIG_IsOK(ecode2)) {
11686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11687 }
11688 arg2 = static_cast< int >(val2);
11689 }
11690 {
11691 PyThreadState* __tstate = wxPyBeginAllowThreads();
11692 result = (PyObject *)(arg1)->readline(arg2);
11693 wxPyEndAllowThreads(__tstate);
11694 if (PyErr_Occurred()) SWIG_fail;
11695 }
11696 resultobj = result;
11697 return resultobj;
11698 fail:
11699 return NULL;
11700 }
11701
11702
11703 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11704 PyObject *resultobj = 0;
11705 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11706 int arg2 = (int) -1 ;
11707 PyObject *result = 0 ;
11708 void *argp1 = 0 ;
11709 int res1 = 0 ;
11710 int val2 ;
11711 int ecode2 = 0 ;
11712 PyObject * obj0 = 0 ;
11713 PyObject * obj1 = 0 ;
11714 char * kwnames[] = {
11715 (char *) "self",(char *) "sizehint", NULL
11716 };
11717
11718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11720 if (!SWIG_IsOK(res1)) {
11721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11722 }
11723 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11724 if (obj1) {
11725 ecode2 = SWIG_AsVal_int(obj1, &val2);
11726 if (!SWIG_IsOK(ecode2)) {
11727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11728 }
11729 arg2 = static_cast< int >(val2);
11730 }
11731 {
11732 PyThreadState* __tstate = wxPyBeginAllowThreads();
11733 result = (PyObject *)(arg1)->readlines(arg2);
11734 wxPyEndAllowThreads(__tstate);
11735 if (PyErr_Occurred()) SWIG_fail;
11736 }
11737 resultobj = result;
11738 return resultobj;
11739 fail:
11740 return NULL;
11741 }
11742
11743
11744 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11745 PyObject *resultobj = 0;
11746 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11747 int arg2 ;
11748 int arg3 = (int) 0 ;
11749 void *argp1 = 0 ;
11750 int res1 = 0 ;
11751 int val2 ;
11752 int ecode2 = 0 ;
11753 int val3 ;
11754 int ecode3 = 0 ;
11755 PyObject * obj0 = 0 ;
11756 PyObject * obj1 = 0 ;
11757 PyObject * obj2 = 0 ;
11758 char * kwnames[] = {
11759 (char *) "self",(char *) "offset",(char *) "whence", NULL
11760 };
11761
11762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11764 if (!SWIG_IsOK(res1)) {
11765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11766 }
11767 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11768 ecode2 = SWIG_AsVal_int(obj1, &val2);
11769 if (!SWIG_IsOK(ecode2)) {
11770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11771 }
11772 arg2 = static_cast< int >(val2);
11773 if (obj2) {
11774 ecode3 = SWIG_AsVal_int(obj2, &val3);
11775 if (!SWIG_IsOK(ecode3)) {
11776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11777 }
11778 arg3 = static_cast< int >(val3);
11779 }
11780 {
11781 PyThreadState* __tstate = wxPyBeginAllowThreads();
11782 (arg1)->seek(arg2,arg3);
11783 wxPyEndAllowThreads(__tstate);
11784 if (PyErr_Occurred()) SWIG_fail;
11785 }
11786 resultobj = SWIG_Py_Void();
11787 return resultobj;
11788 fail:
11789 return NULL;
11790 }
11791
11792
11793 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11794 PyObject *resultobj = 0;
11795 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11796 int result;
11797 void *argp1 = 0 ;
11798 int res1 = 0 ;
11799 PyObject *swig_obj[1] ;
11800
11801 if (!args) SWIG_fail;
11802 swig_obj[0] = args;
11803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11804 if (!SWIG_IsOK(res1)) {
11805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11806 }
11807 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11808 {
11809 PyThreadState* __tstate = wxPyBeginAllowThreads();
11810 result = (int)(arg1)->tell();
11811 wxPyEndAllowThreads(__tstate);
11812 if (PyErr_Occurred()) SWIG_fail;
11813 }
11814 resultobj = SWIG_From_int(static_cast< int >(result));
11815 return resultobj;
11816 fail:
11817 return NULL;
11818 }
11819
11820
11821 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11822 PyObject *resultobj = 0;
11823 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11824 char result;
11825 void *argp1 = 0 ;
11826 int res1 = 0 ;
11827 PyObject *swig_obj[1] ;
11828
11829 if (!args) SWIG_fail;
11830 swig_obj[0] = args;
11831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11832 if (!SWIG_IsOK(res1)) {
11833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11834 }
11835 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11836 {
11837 PyThreadState* __tstate = wxPyBeginAllowThreads();
11838 result = (char)(arg1)->Peek();
11839 wxPyEndAllowThreads(__tstate);
11840 if (PyErr_Occurred()) SWIG_fail;
11841 }
11842 resultobj = SWIG_From_char(static_cast< char >(result));
11843 return resultobj;
11844 fail:
11845 return NULL;
11846 }
11847
11848
11849 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11850 PyObject *resultobj = 0;
11851 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11852 char result;
11853 void *argp1 = 0 ;
11854 int res1 = 0 ;
11855 PyObject *swig_obj[1] ;
11856
11857 if (!args) SWIG_fail;
11858 swig_obj[0] = args;
11859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11860 if (!SWIG_IsOK(res1)) {
11861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11862 }
11863 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11864 {
11865 PyThreadState* __tstate = wxPyBeginAllowThreads();
11866 result = (char)(arg1)->GetC();
11867 wxPyEndAllowThreads(__tstate);
11868 if (PyErr_Occurred()) SWIG_fail;
11869 }
11870 resultobj = SWIG_From_char(static_cast< char >(result));
11871 return resultobj;
11872 fail:
11873 return NULL;
11874 }
11875
11876
11877 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11878 PyObject *resultobj = 0;
11879 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11880 size_t result;
11881 void *argp1 = 0 ;
11882 int res1 = 0 ;
11883 PyObject *swig_obj[1] ;
11884
11885 if (!args) SWIG_fail;
11886 swig_obj[0] = args;
11887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11888 if (!SWIG_IsOK(res1)) {
11889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11890 }
11891 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11892 {
11893 PyThreadState* __tstate = wxPyBeginAllowThreads();
11894 result = (size_t)(arg1)->LastRead();
11895 wxPyEndAllowThreads(__tstate);
11896 if (PyErr_Occurred()) SWIG_fail;
11897 }
11898 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11899 return resultobj;
11900 fail:
11901 return NULL;
11902 }
11903
11904
11905 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11906 PyObject *resultobj = 0;
11907 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11908 bool result;
11909 void *argp1 = 0 ;
11910 int res1 = 0 ;
11911 PyObject *swig_obj[1] ;
11912
11913 if (!args) SWIG_fail;
11914 swig_obj[0] = args;
11915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11916 if (!SWIG_IsOK(res1)) {
11917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11918 }
11919 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11920 {
11921 PyThreadState* __tstate = wxPyBeginAllowThreads();
11922 result = (bool)(arg1)->CanRead();
11923 wxPyEndAllowThreads(__tstate);
11924 if (PyErr_Occurred()) SWIG_fail;
11925 }
11926 {
11927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11928 }
11929 return resultobj;
11930 fail:
11931 return NULL;
11932 }
11933
11934
11935 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11936 PyObject *resultobj = 0;
11937 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11938 bool result;
11939 void *argp1 = 0 ;
11940 int res1 = 0 ;
11941 PyObject *swig_obj[1] ;
11942
11943 if (!args) SWIG_fail;
11944 swig_obj[0] = args;
11945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11946 if (!SWIG_IsOK(res1)) {
11947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11948 }
11949 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11950 {
11951 PyThreadState* __tstate = wxPyBeginAllowThreads();
11952 result = (bool)(arg1)->Eof();
11953 wxPyEndAllowThreads(__tstate);
11954 if (PyErr_Occurred()) SWIG_fail;
11955 }
11956 {
11957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11958 }
11959 return resultobj;
11960 fail:
11961 return NULL;
11962 }
11963
11964
11965 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11966 PyObject *resultobj = 0;
11967 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11968 char arg2 ;
11969 bool result;
11970 void *argp1 = 0 ;
11971 int res1 = 0 ;
11972 char val2 ;
11973 int ecode2 = 0 ;
11974 PyObject * obj0 = 0 ;
11975 PyObject * obj1 = 0 ;
11976 char * kwnames[] = {
11977 (char *) "self",(char *) "c", NULL
11978 };
11979
11980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11982 if (!SWIG_IsOK(res1)) {
11983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11984 }
11985 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11986 ecode2 = SWIG_AsVal_char(obj1, &val2);
11987 if (!SWIG_IsOK(ecode2)) {
11988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
11989 }
11990 arg2 = static_cast< char >(val2);
11991 {
11992 PyThreadState* __tstate = wxPyBeginAllowThreads();
11993 result = (bool)(arg1)->Ungetch(arg2);
11994 wxPyEndAllowThreads(__tstate);
11995 if (PyErr_Occurred()) SWIG_fail;
11996 }
11997 {
11998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11999 }
12000 return resultobj;
12001 fail:
12002 return NULL;
12003 }
12004
12005
12006 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12007 PyObject *resultobj = 0;
12008 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12009 long arg2 ;
12010 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
12011 long result;
12012 void *argp1 = 0 ;
12013 int res1 = 0 ;
12014 long val2 ;
12015 int ecode2 = 0 ;
12016 int val3 ;
12017 int ecode3 = 0 ;
12018 PyObject * obj0 = 0 ;
12019 PyObject * obj1 = 0 ;
12020 PyObject * obj2 = 0 ;
12021 char * kwnames[] = {
12022 (char *) "self",(char *) "pos",(char *) "mode", NULL
12023 };
12024
12025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12027 if (!SWIG_IsOK(res1)) {
12028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12029 }
12030 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12031 ecode2 = SWIG_AsVal_long(obj1, &val2);
12032 if (!SWIG_IsOK(ecode2)) {
12033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
12034 }
12035 arg2 = static_cast< long >(val2);
12036 if (obj2) {
12037 ecode3 = SWIG_AsVal_int(obj2, &val3);
12038 if (!SWIG_IsOK(ecode3)) {
12039 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
12040 }
12041 arg3 = static_cast< wxSeekMode >(val3);
12042 }
12043 {
12044 PyThreadState* __tstate = wxPyBeginAllowThreads();
12045 result = (long)(arg1)->SeekI(arg2,arg3);
12046 wxPyEndAllowThreads(__tstate);
12047 if (PyErr_Occurred()) SWIG_fail;
12048 }
12049 resultobj = SWIG_From_long(static_cast< long >(result));
12050 return resultobj;
12051 fail:
12052 return NULL;
12053 }
12054
12055
12056 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12057 PyObject *resultobj = 0;
12058 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12059 long result;
12060 void *argp1 = 0 ;
12061 int res1 = 0 ;
12062 PyObject *swig_obj[1] ;
12063
12064 if (!args) SWIG_fail;
12065 swig_obj[0] = args;
12066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12067 if (!SWIG_IsOK(res1)) {
12068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12069 }
12070 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12071 {
12072 PyThreadState* __tstate = wxPyBeginAllowThreads();
12073 result = (long)(arg1)->TellI();
12074 wxPyEndAllowThreads(__tstate);
12075 if (PyErr_Occurred()) SWIG_fail;
12076 }
12077 resultobj = SWIG_From_long(static_cast< long >(result));
12078 return resultobj;
12079 fail:
12080 return NULL;
12081 }
12082
12083
12084 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12085 PyObject *obj;
12086 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12087 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12088 return SWIG_Py_Void();
12089 }
12090
12091 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12092 return SWIG_Python_InitShadowInstance(args);
12093 }
12094
12095 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12096 PyObject *resultobj = 0;
12097 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12098 PyObject *arg2 = (PyObject *) 0 ;
12099 void *argp1 = 0 ;
12100 int res1 = 0 ;
12101 PyObject * obj0 = 0 ;
12102 PyObject * obj1 = 0 ;
12103 char * kwnames[] = {
12104 (char *) "self",(char *) "obj", NULL
12105 };
12106
12107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12109 if (!SWIG_IsOK(res1)) {
12110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12111 }
12112 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12113 arg2 = obj1;
12114 {
12115 PyThreadState* __tstate = wxPyBeginAllowThreads();
12116 wxOutputStream_write(arg1,arg2);
12117 wxPyEndAllowThreads(__tstate);
12118 if (PyErr_Occurred()) SWIG_fail;
12119 }
12120 resultobj = SWIG_Py_Void();
12121 return resultobj;
12122 fail:
12123 return NULL;
12124 }
12125
12126
12127 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12128 PyObject *resultobj = 0;
12129 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12130 size_t result;
12131 void *argp1 = 0 ;
12132 int res1 = 0 ;
12133 PyObject *swig_obj[1] ;
12134
12135 if (!args) SWIG_fail;
12136 swig_obj[0] = args;
12137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12138 if (!SWIG_IsOK(res1)) {
12139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12140 }
12141 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12142 {
12143 PyThreadState* __tstate = wxPyBeginAllowThreads();
12144 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12145 wxPyEndAllowThreads(__tstate);
12146 if (PyErr_Occurred()) SWIG_fail;
12147 }
12148 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12149 return resultobj;
12150 fail:
12151 return NULL;
12152 }
12153
12154
12155 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12156 PyObject *obj;
12157 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12158 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12159 return SWIG_Py_Void();
12160 }
12161
12162 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12163 PyObject *resultobj = 0;
12164 wxInputStream *arg1 = (wxInputStream *) 0 ;
12165 wxString *arg2 = 0 ;
12166 wxString *arg3 = 0 ;
12167 wxString *arg4 = 0 ;
12168 wxDateTime arg5 ;
12169 wxFSFile *result = 0 ;
12170 wxPyInputStream *temp1 ;
12171 bool temp2 = false ;
12172 bool temp3 = false ;
12173 bool temp4 = false ;
12174 void *argp5 ;
12175 int res5 = 0 ;
12176 PyObject * obj0 = 0 ;
12177 PyObject * obj1 = 0 ;
12178 PyObject * obj2 = 0 ;
12179 PyObject * obj3 = 0 ;
12180 PyObject * obj4 = 0 ;
12181 char * kwnames[] = {
12182 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12183 };
12184
12185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12186 {
12187 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12188 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12189 } else {
12190 PyErr_Clear(); // clear the failure of the wxPyConvert above
12191 arg1 = wxPyCBInputStream_create(obj0, true);
12192 if (arg1 == NULL) {
12193 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12194 SWIG_fail;
12195 }
12196 }
12197 }
12198 {
12199 arg2 = wxString_in_helper(obj1);
12200 if (arg2 == NULL) SWIG_fail;
12201 temp2 = true;
12202 }
12203 {
12204 arg3 = wxString_in_helper(obj2);
12205 if (arg3 == NULL) SWIG_fail;
12206 temp3 = true;
12207 }
12208 {
12209 arg4 = wxString_in_helper(obj3);
12210 if (arg4 == NULL) SWIG_fail;
12211 temp4 = true;
12212 }
12213 {
12214 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12215 if (!SWIG_IsOK(res5)) {
12216 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12217 }
12218 if (!argp5) {
12219 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12220 } else {
12221 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12222 arg5 = *temp;
12223 if (SWIG_IsNewObj(res5)) delete temp;
12224 }
12225 }
12226 {
12227 PyThreadState* __tstate = wxPyBeginAllowThreads();
12228 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12229 wxPyEndAllowThreads(__tstate);
12230 if (PyErr_Occurred()) SWIG_fail;
12231 }
12232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12233 {
12234 if (temp2)
12235 delete arg2;
12236 }
12237 {
12238 if (temp3)
12239 delete arg3;
12240 }
12241 {
12242 if (temp4)
12243 delete arg4;
12244 }
12245 return resultobj;
12246 fail:
12247 {
12248 if (temp2)
12249 delete arg2;
12250 }
12251 {
12252 if (temp3)
12253 delete arg3;
12254 }
12255 {
12256 if (temp4)
12257 delete arg4;
12258 }
12259 return NULL;
12260 }
12261
12262
12263 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12264 PyObject *resultobj = 0;
12265 wxFSFile *arg1 = (wxFSFile *) 0 ;
12266 void *argp1 = 0 ;
12267 int res1 = 0 ;
12268 PyObject *swig_obj[1] ;
12269
12270 if (!args) SWIG_fail;
12271 swig_obj[0] = args;
12272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12273 if (!SWIG_IsOK(res1)) {
12274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12275 }
12276 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12277 {
12278 PyThreadState* __tstate = wxPyBeginAllowThreads();
12279 delete arg1;
12280
12281 wxPyEndAllowThreads(__tstate);
12282 if (PyErr_Occurred()) SWIG_fail;
12283 }
12284 resultobj = SWIG_Py_Void();
12285 return resultobj;
12286 fail:
12287 return NULL;
12288 }
12289
12290
12291 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12292 PyObject *resultobj = 0;
12293 wxFSFile *arg1 = (wxFSFile *) 0 ;
12294 wxInputStream *result = 0 ;
12295 void *argp1 = 0 ;
12296 int res1 = 0 ;
12297 PyObject *swig_obj[1] ;
12298
12299 if (!args) SWIG_fail;
12300 swig_obj[0] = args;
12301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12302 if (!SWIG_IsOK(res1)) {
12303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12304 }
12305 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12306 {
12307 PyThreadState* __tstate = wxPyBeginAllowThreads();
12308 result = (wxInputStream *)(arg1)->GetStream();
12309 wxPyEndAllowThreads(__tstate);
12310 if (PyErr_Occurred()) SWIG_fail;
12311 }
12312 {
12313 wxPyInputStream * _ptr = NULL;
12314
12315 if (result) {
12316 _ptr = new wxPyInputStream(result);
12317 }
12318 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12319 }
12320 return resultobj;
12321 fail:
12322 return NULL;
12323 }
12324
12325
12326 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12327 PyObject *resultobj = 0;
12328 wxFSFile *arg1 = (wxFSFile *) 0 ;
12329 void *argp1 = 0 ;
12330 int res1 = 0 ;
12331 PyObject *swig_obj[1] ;
12332
12333 if (!args) SWIG_fail;
12334 swig_obj[0] = args;
12335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12336 if (!SWIG_IsOK(res1)) {
12337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12338 }
12339 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12340 {
12341 PyThreadState* __tstate = wxPyBeginAllowThreads();
12342 (arg1)->DetachStream();
12343 wxPyEndAllowThreads(__tstate);
12344 if (PyErr_Occurred()) SWIG_fail;
12345 }
12346 resultobj = SWIG_Py_Void();
12347 return resultobj;
12348 fail:
12349 return NULL;
12350 }
12351
12352
12353 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12354 PyObject *resultobj = 0;
12355 wxFSFile *arg1 = (wxFSFile *) 0 ;
12356 wxString *result = 0 ;
12357 void *argp1 = 0 ;
12358 int res1 = 0 ;
12359 PyObject *swig_obj[1] ;
12360
12361 if (!args) SWIG_fail;
12362 swig_obj[0] = args;
12363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12364 if (!SWIG_IsOK(res1)) {
12365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12366 }
12367 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12368 {
12369 PyThreadState* __tstate = wxPyBeginAllowThreads();
12370 {
12371 wxString const &_result_ref = (arg1)->GetMimeType();
12372 result = (wxString *) &_result_ref;
12373 }
12374 wxPyEndAllowThreads(__tstate);
12375 if (PyErr_Occurred()) SWIG_fail;
12376 }
12377 {
12378 #if wxUSE_UNICODE
12379 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12380 #else
12381 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12382 #endif
12383 }
12384 return resultobj;
12385 fail:
12386 return NULL;
12387 }
12388
12389
12390 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12391 PyObject *resultobj = 0;
12392 wxFSFile *arg1 = (wxFSFile *) 0 ;
12393 wxString *result = 0 ;
12394 void *argp1 = 0 ;
12395 int res1 = 0 ;
12396 PyObject *swig_obj[1] ;
12397
12398 if (!args) SWIG_fail;
12399 swig_obj[0] = args;
12400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12401 if (!SWIG_IsOK(res1)) {
12402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12403 }
12404 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12405 {
12406 PyThreadState* __tstate = wxPyBeginAllowThreads();
12407 {
12408 wxString const &_result_ref = (arg1)->GetLocation();
12409 result = (wxString *) &_result_ref;
12410 }
12411 wxPyEndAllowThreads(__tstate);
12412 if (PyErr_Occurred()) SWIG_fail;
12413 }
12414 {
12415 #if wxUSE_UNICODE
12416 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12417 #else
12418 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12419 #endif
12420 }
12421 return resultobj;
12422 fail:
12423 return NULL;
12424 }
12425
12426
12427 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12428 PyObject *resultobj = 0;
12429 wxFSFile *arg1 = (wxFSFile *) 0 ;
12430 wxString *result = 0 ;
12431 void *argp1 = 0 ;
12432 int res1 = 0 ;
12433 PyObject *swig_obj[1] ;
12434
12435 if (!args) SWIG_fail;
12436 swig_obj[0] = args;
12437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12438 if (!SWIG_IsOK(res1)) {
12439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12440 }
12441 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12442 {
12443 PyThreadState* __tstate = wxPyBeginAllowThreads();
12444 {
12445 wxString const &_result_ref = (arg1)->GetAnchor();
12446 result = (wxString *) &_result_ref;
12447 }
12448 wxPyEndAllowThreads(__tstate);
12449 if (PyErr_Occurred()) SWIG_fail;
12450 }
12451 {
12452 #if wxUSE_UNICODE
12453 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12454 #else
12455 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12456 #endif
12457 }
12458 return resultobj;
12459 fail:
12460 return NULL;
12461 }
12462
12463
12464 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12465 PyObject *resultobj = 0;
12466 wxFSFile *arg1 = (wxFSFile *) 0 ;
12467 wxDateTime result;
12468 void *argp1 = 0 ;
12469 int res1 = 0 ;
12470 PyObject *swig_obj[1] ;
12471
12472 if (!args) SWIG_fail;
12473 swig_obj[0] = args;
12474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12475 if (!SWIG_IsOK(res1)) {
12476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12477 }
12478 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12479 {
12480 PyThreadState* __tstate = wxPyBeginAllowThreads();
12481 result = (arg1)->GetModificationTime();
12482 wxPyEndAllowThreads(__tstate);
12483 if (PyErr_Occurred()) SWIG_fail;
12484 }
12485 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12486 return resultobj;
12487 fail:
12488 return NULL;
12489 }
12490
12491
12492 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12493 PyObject *obj;
12494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12495 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12496 return SWIG_Py_Void();
12497 }
12498
12499 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12500 return SWIG_Python_InitShadowInstance(args);
12501 }
12502
12503 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12504 PyObject *resultobj = 0;
12505 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12506 void *argp1 = 0 ;
12507 int res1 = 0 ;
12508 PyObject *swig_obj[1] ;
12509
12510 if (!args) SWIG_fail;
12511 swig_obj[0] = args;
12512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12513 if (!SWIG_IsOK(res1)) {
12514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12515 }
12516 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12517 {
12518 PyThreadState* __tstate = wxPyBeginAllowThreads();
12519 delete arg1;
12520
12521 wxPyEndAllowThreads(__tstate);
12522 if (PyErr_Occurred()) SWIG_fail;
12523 }
12524 resultobj = SWIG_Py_Void();
12525 return resultobj;
12526 fail:
12527 return NULL;
12528 }
12529
12530
12531 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12532 PyObject *obj;
12533 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12534 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12535 return SWIG_Py_Void();
12536 }
12537
12538 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12539 PyObject *resultobj = 0;
12540 wxPyFileSystemHandler *result = 0 ;
12541
12542 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12543 {
12544 PyThreadState* __tstate = wxPyBeginAllowThreads();
12545 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12546 wxPyEndAllowThreads(__tstate);
12547 if (PyErr_Occurred()) SWIG_fail;
12548 }
12549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12550 return resultobj;
12551 fail:
12552 return NULL;
12553 }
12554
12555
12556 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12557 PyObject *resultobj = 0;
12558 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12559 PyObject *arg2 = (PyObject *) 0 ;
12560 PyObject *arg3 = (PyObject *) 0 ;
12561 void *argp1 = 0 ;
12562 int res1 = 0 ;
12563 PyObject * obj0 = 0 ;
12564 PyObject * obj1 = 0 ;
12565 PyObject * obj2 = 0 ;
12566 char * kwnames[] = {
12567 (char *) "self",(char *) "self",(char *) "_class", NULL
12568 };
12569
12570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12572 if (!SWIG_IsOK(res1)) {
12573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12574 }
12575 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12576 arg2 = obj1;
12577 arg3 = obj2;
12578 {
12579 PyThreadState* __tstate = wxPyBeginAllowThreads();
12580 (arg1)->_setCallbackInfo(arg2,arg3);
12581 wxPyEndAllowThreads(__tstate);
12582 if (PyErr_Occurred()) SWIG_fail;
12583 }
12584 resultobj = SWIG_Py_Void();
12585 return resultobj;
12586 fail:
12587 return NULL;
12588 }
12589
12590
12591 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12592 PyObject *resultobj = 0;
12593 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12594 wxString *arg2 = 0 ;
12595 bool result;
12596 void *argp1 = 0 ;
12597 int res1 = 0 ;
12598 bool temp2 = false ;
12599 PyObject * obj0 = 0 ;
12600 PyObject * obj1 = 0 ;
12601 char * kwnames[] = {
12602 (char *) "self",(char *) "location", NULL
12603 };
12604
12605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12607 if (!SWIG_IsOK(res1)) {
12608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12609 }
12610 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12611 {
12612 arg2 = wxString_in_helper(obj1);
12613 if (arg2 == NULL) SWIG_fail;
12614 temp2 = true;
12615 }
12616 {
12617 PyThreadState* __tstate = wxPyBeginAllowThreads();
12618 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12619 wxPyEndAllowThreads(__tstate);
12620 if (PyErr_Occurred()) SWIG_fail;
12621 }
12622 {
12623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12624 }
12625 {
12626 if (temp2)
12627 delete arg2;
12628 }
12629 return resultobj;
12630 fail:
12631 {
12632 if (temp2)
12633 delete arg2;
12634 }
12635 return NULL;
12636 }
12637
12638
12639 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12640 PyObject *resultobj = 0;
12641 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12642 wxFileSystem *arg2 = 0 ;
12643 wxString *arg3 = 0 ;
12644 wxFSFile *result = 0 ;
12645 void *argp1 = 0 ;
12646 int res1 = 0 ;
12647 void *argp2 = 0 ;
12648 int res2 = 0 ;
12649 bool temp3 = false ;
12650 PyObject * obj0 = 0 ;
12651 PyObject * obj1 = 0 ;
12652 PyObject * obj2 = 0 ;
12653 char * kwnames[] = {
12654 (char *) "self",(char *) "fs",(char *) "location", NULL
12655 };
12656
12657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12659 if (!SWIG_IsOK(res1)) {
12660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12661 }
12662 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12663 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12664 if (!SWIG_IsOK(res2)) {
12665 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12666 }
12667 if (!argp2) {
12668 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12669 }
12670 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12671 {
12672 arg3 = wxString_in_helper(obj2);
12673 if (arg3 == NULL) SWIG_fail;
12674 temp3 = true;
12675 }
12676 {
12677 PyThreadState* __tstate = wxPyBeginAllowThreads();
12678 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12679 wxPyEndAllowThreads(__tstate);
12680 if (PyErr_Occurred()) SWIG_fail;
12681 }
12682 {
12683 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
12684 }
12685 {
12686 if (temp3)
12687 delete arg3;
12688 }
12689 return resultobj;
12690 fail:
12691 {
12692 if (temp3)
12693 delete arg3;
12694 }
12695 return NULL;
12696 }
12697
12698
12699 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12700 PyObject *resultobj = 0;
12701 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12702 wxString *arg2 = 0 ;
12703 int arg3 = (int) 0 ;
12704 wxString result;
12705 void *argp1 = 0 ;
12706 int res1 = 0 ;
12707 bool temp2 = false ;
12708 int val3 ;
12709 int ecode3 = 0 ;
12710 PyObject * obj0 = 0 ;
12711 PyObject * obj1 = 0 ;
12712 PyObject * obj2 = 0 ;
12713 char * kwnames[] = {
12714 (char *) "self",(char *) "spec",(char *) "flags", NULL
12715 };
12716
12717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12719 if (!SWIG_IsOK(res1)) {
12720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12721 }
12722 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12723 {
12724 arg2 = wxString_in_helper(obj1);
12725 if (arg2 == NULL) SWIG_fail;
12726 temp2 = true;
12727 }
12728 if (obj2) {
12729 ecode3 = SWIG_AsVal_int(obj2, &val3);
12730 if (!SWIG_IsOK(ecode3)) {
12731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12732 }
12733 arg3 = static_cast< int >(val3);
12734 }
12735 {
12736 PyThreadState* __tstate = wxPyBeginAllowThreads();
12737 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12738 wxPyEndAllowThreads(__tstate);
12739 if (PyErr_Occurred()) SWIG_fail;
12740 }
12741 {
12742 #if wxUSE_UNICODE
12743 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12744 #else
12745 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12746 #endif
12747 }
12748 {
12749 if (temp2)
12750 delete arg2;
12751 }
12752 return resultobj;
12753 fail:
12754 {
12755 if (temp2)
12756 delete arg2;
12757 }
12758 return NULL;
12759 }
12760
12761
12762 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12763 PyObject *resultobj = 0;
12764 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12765 wxString result;
12766 void *argp1 = 0 ;
12767 int res1 = 0 ;
12768 PyObject *swig_obj[1] ;
12769
12770 if (!args) SWIG_fail;
12771 swig_obj[0] = args;
12772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12773 if (!SWIG_IsOK(res1)) {
12774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12775 }
12776 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12777 {
12778 PyThreadState* __tstate = wxPyBeginAllowThreads();
12779 result = (arg1)->FindNext();
12780 wxPyEndAllowThreads(__tstate);
12781 if (PyErr_Occurred()) SWIG_fail;
12782 }
12783 {
12784 #if wxUSE_UNICODE
12785 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12786 #else
12787 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12788 #endif
12789 }
12790 return resultobj;
12791 fail:
12792 return NULL;
12793 }
12794
12795
12796 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12797 PyObject *resultobj = 0;
12798 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12799 wxString *arg2 = 0 ;
12800 wxString result;
12801 void *argp1 = 0 ;
12802 int res1 = 0 ;
12803 bool temp2 = false ;
12804 PyObject * obj0 = 0 ;
12805 PyObject * obj1 = 0 ;
12806 char * kwnames[] = {
12807 (char *) "self",(char *) "location", NULL
12808 };
12809
12810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12812 if (!SWIG_IsOK(res1)) {
12813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12814 }
12815 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12816 {
12817 arg2 = wxString_in_helper(obj1);
12818 if (arg2 == NULL) SWIG_fail;
12819 temp2 = true;
12820 }
12821 {
12822 PyThreadState* __tstate = wxPyBeginAllowThreads();
12823 result = (arg1)->GetProtocol((wxString const &)*arg2);
12824 wxPyEndAllowThreads(__tstate);
12825 if (PyErr_Occurred()) SWIG_fail;
12826 }
12827 {
12828 #if wxUSE_UNICODE
12829 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12830 #else
12831 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12832 #endif
12833 }
12834 {
12835 if (temp2)
12836 delete arg2;
12837 }
12838 return resultobj;
12839 fail:
12840 {
12841 if (temp2)
12842 delete arg2;
12843 }
12844 return NULL;
12845 }
12846
12847
12848 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12849 PyObject *resultobj = 0;
12850 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12851 wxString *arg2 = 0 ;
12852 wxString result;
12853 void *argp1 = 0 ;
12854 int res1 = 0 ;
12855 bool temp2 = false ;
12856 PyObject * obj0 = 0 ;
12857 PyObject * obj1 = 0 ;
12858 char * kwnames[] = {
12859 (char *) "self",(char *) "location", NULL
12860 };
12861
12862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12864 if (!SWIG_IsOK(res1)) {
12865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12866 }
12867 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12868 {
12869 arg2 = wxString_in_helper(obj1);
12870 if (arg2 == NULL) SWIG_fail;
12871 temp2 = true;
12872 }
12873 {
12874 PyThreadState* __tstate = wxPyBeginAllowThreads();
12875 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12876 wxPyEndAllowThreads(__tstate);
12877 if (PyErr_Occurred()) SWIG_fail;
12878 }
12879 {
12880 #if wxUSE_UNICODE
12881 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12882 #else
12883 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12884 #endif
12885 }
12886 {
12887 if (temp2)
12888 delete arg2;
12889 }
12890 return resultobj;
12891 fail:
12892 {
12893 if (temp2)
12894 delete arg2;
12895 }
12896 return NULL;
12897 }
12898
12899
12900 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12901 PyObject *resultobj = 0;
12902 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12903 wxString *arg2 = 0 ;
12904 wxString result;
12905 void *argp1 = 0 ;
12906 int res1 = 0 ;
12907 bool temp2 = false ;
12908 PyObject * obj0 = 0 ;
12909 PyObject * obj1 = 0 ;
12910 char * kwnames[] = {
12911 (char *) "self",(char *) "location", NULL
12912 };
12913
12914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12916 if (!SWIG_IsOK(res1)) {
12917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12918 }
12919 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12920 {
12921 arg2 = wxString_in_helper(obj1);
12922 if (arg2 == NULL) SWIG_fail;
12923 temp2 = true;
12924 }
12925 {
12926 PyThreadState* __tstate = wxPyBeginAllowThreads();
12927 result = (arg1)->GetAnchor((wxString const &)*arg2);
12928 wxPyEndAllowThreads(__tstate);
12929 if (PyErr_Occurred()) SWIG_fail;
12930 }
12931 {
12932 #if wxUSE_UNICODE
12933 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12934 #else
12935 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12936 #endif
12937 }
12938 {
12939 if (temp2)
12940 delete arg2;
12941 }
12942 return resultobj;
12943 fail:
12944 {
12945 if (temp2)
12946 delete arg2;
12947 }
12948 return NULL;
12949 }
12950
12951
12952 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12953 PyObject *resultobj = 0;
12954 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12955 wxString *arg2 = 0 ;
12956 wxString result;
12957 void *argp1 = 0 ;
12958 int res1 = 0 ;
12959 bool temp2 = false ;
12960 PyObject * obj0 = 0 ;
12961 PyObject * obj1 = 0 ;
12962 char * kwnames[] = {
12963 (char *) "self",(char *) "location", NULL
12964 };
12965
12966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12968 if (!SWIG_IsOK(res1)) {
12969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12970 }
12971 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12972 {
12973 arg2 = wxString_in_helper(obj1);
12974 if (arg2 == NULL) SWIG_fail;
12975 temp2 = true;
12976 }
12977 {
12978 PyThreadState* __tstate = wxPyBeginAllowThreads();
12979 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12980 wxPyEndAllowThreads(__tstate);
12981 if (PyErr_Occurred()) SWIG_fail;
12982 }
12983 {
12984 #if wxUSE_UNICODE
12985 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12986 #else
12987 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12988 #endif
12989 }
12990 {
12991 if (temp2)
12992 delete arg2;
12993 }
12994 return resultobj;
12995 fail:
12996 {
12997 if (temp2)
12998 delete arg2;
12999 }
13000 return NULL;
13001 }
13002
13003
13004 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13005 PyObject *resultobj = 0;
13006 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13007 wxString *arg2 = 0 ;
13008 wxString result;
13009 void *argp1 = 0 ;
13010 int res1 = 0 ;
13011 bool temp2 = false ;
13012 PyObject * obj0 = 0 ;
13013 PyObject * obj1 = 0 ;
13014 char * kwnames[] = {
13015 (char *) "self",(char *) "location", NULL
13016 };
13017
13018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
13019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13020 if (!SWIG_IsOK(res1)) {
13021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13022 }
13023 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13024 {
13025 arg2 = wxString_in_helper(obj1);
13026 if (arg2 == NULL) SWIG_fail;
13027 temp2 = true;
13028 }
13029 {
13030 PyThreadState* __tstate = wxPyBeginAllowThreads();
13031 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
13032 wxPyEndAllowThreads(__tstate);
13033 if (PyErr_Occurred()) SWIG_fail;
13034 }
13035 {
13036 #if wxUSE_UNICODE
13037 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13038 #else
13039 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13040 #endif
13041 }
13042 {
13043 if (temp2)
13044 delete arg2;
13045 }
13046 return resultobj;
13047 fail:
13048 {
13049 if (temp2)
13050 delete arg2;
13051 }
13052 return NULL;
13053 }
13054
13055
13056 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13057 PyObject *obj;
13058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13059 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
13060 return SWIG_Py_Void();
13061 }
13062
13063 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13064 return SWIG_Python_InitShadowInstance(args);
13065 }
13066
13067 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13068 PyObject *resultobj = 0;
13069 wxFileSystem *result = 0 ;
13070
13071 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13072 {
13073 PyThreadState* __tstate = wxPyBeginAllowThreads();
13074 result = (wxFileSystem *)new wxFileSystem();
13075 wxPyEndAllowThreads(__tstate);
13076 if (PyErr_Occurred()) SWIG_fail;
13077 }
13078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13079 return resultobj;
13080 fail:
13081 return NULL;
13082 }
13083
13084
13085 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13086 PyObject *resultobj = 0;
13087 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13088 void *argp1 = 0 ;
13089 int res1 = 0 ;
13090 PyObject *swig_obj[1] ;
13091
13092 if (!args) SWIG_fail;
13093 swig_obj[0] = args;
13094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13095 if (!SWIG_IsOK(res1)) {
13096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13097 }
13098 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13099 {
13100 PyThreadState* __tstate = wxPyBeginAllowThreads();
13101 delete arg1;
13102
13103 wxPyEndAllowThreads(__tstate);
13104 if (PyErr_Occurred()) SWIG_fail;
13105 }
13106 resultobj = SWIG_Py_Void();
13107 return resultobj;
13108 fail:
13109 return NULL;
13110 }
13111
13112
13113 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13114 PyObject *resultobj = 0;
13115 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13116 wxString *arg2 = 0 ;
13117 bool arg3 = (bool) false ;
13118 void *argp1 = 0 ;
13119 int res1 = 0 ;
13120 bool temp2 = false ;
13121 bool val3 ;
13122 int ecode3 = 0 ;
13123 PyObject * obj0 = 0 ;
13124 PyObject * obj1 = 0 ;
13125 PyObject * obj2 = 0 ;
13126 char * kwnames[] = {
13127 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13128 };
13129
13130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13132 if (!SWIG_IsOK(res1)) {
13133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13134 }
13135 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13136 {
13137 arg2 = wxString_in_helper(obj1);
13138 if (arg2 == NULL) SWIG_fail;
13139 temp2 = true;
13140 }
13141 if (obj2) {
13142 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13143 if (!SWIG_IsOK(ecode3)) {
13144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13145 }
13146 arg3 = static_cast< bool >(val3);
13147 }
13148 {
13149 PyThreadState* __tstate = wxPyBeginAllowThreads();
13150 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13151 wxPyEndAllowThreads(__tstate);
13152 if (PyErr_Occurred()) SWIG_fail;
13153 }
13154 resultobj = SWIG_Py_Void();
13155 {
13156 if (temp2)
13157 delete arg2;
13158 }
13159 return resultobj;
13160 fail:
13161 {
13162 if (temp2)
13163 delete arg2;
13164 }
13165 return NULL;
13166 }
13167
13168
13169 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13170 PyObject *resultobj = 0;
13171 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13172 wxString result;
13173 void *argp1 = 0 ;
13174 int res1 = 0 ;
13175 PyObject *swig_obj[1] ;
13176
13177 if (!args) SWIG_fail;
13178 swig_obj[0] = args;
13179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13180 if (!SWIG_IsOK(res1)) {
13181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13182 }
13183 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13184 {
13185 PyThreadState* __tstate = wxPyBeginAllowThreads();
13186 result = (arg1)->GetPath();
13187 wxPyEndAllowThreads(__tstate);
13188 if (PyErr_Occurred()) SWIG_fail;
13189 }
13190 {
13191 #if wxUSE_UNICODE
13192 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13193 #else
13194 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13195 #endif
13196 }
13197 return resultobj;
13198 fail:
13199 return NULL;
13200 }
13201
13202
13203 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13204 PyObject *resultobj = 0;
13205 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13206 wxString *arg2 = 0 ;
13207 wxFSFile *result = 0 ;
13208 void *argp1 = 0 ;
13209 int res1 = 0 ;
13210 bool temp2 = false ;
13211 PyObject * obj0 = 0 ;
13212 PyObject * obj1 = 0 ;
13213 char * kwnames[] = {
13214 (char *) "self",(char *) "location", NULL
13215 };
13216
13217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13219 if (!SWIG_IsOK(res1)) {
13220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13221 }
13222 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13223 {
13224 arg2 = wxString_in_helper(obj1);
13225 if (arg2 == NULL) SWIG_fail;
13226 temp2 = true;
13227 }
13228 {
13229 PyThreadState* __tstate = wxPyBeginAllowThreads();
13230 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13231 wxPyEndAllowThreads(__tstate);
13232 if (PyErr_Occurred()) SWIG_fail;
13233 }
13234 {
13235 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13236 }
13237 {
13238 if (temp2)
13239 delete arg2;
13240 }
13241 return resultobj;
13242 fail:
13243 {
13244 if (temp2)
13245 delete arg2;
13246 }
13247 return NULL;
13248 }
13249
13250
13251 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13252 PyObject *resultobj = 0;
13253 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13254 wxString *arg2 = 0 ;
13255 int arg3 = (int) 0 ;
13256 wxString result;
13257 void *argp1 = 0 ;
13258 int res1 = 0 ;
13259 bool temp2 = false ;
13260 int val3 ;
13261 int ecode3 = 0 ;
13262 PyObject * obj0 = 0 ;
13263 PyObject * obj1 = 0 ;
13264 PyObject * obj2 = 0 ;
13265 char * kwnames[] = {
13266 (char *) "self",(char *) "spec",(char *) "flags", NULL
13267 };
13268
13269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13271 if (!SWIG_IsOK(res1)) {
13272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13273 }
13274 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13275 {
13276 arg2 = wxString_in_helper(obj1);
13277 if (arg2 == NULL) SWIG_fail;
13278 temp2 = true;
13279 }
13280 if (obj2) {
13281 ecode3 = SWIG_AsVal_int(obj2, &val3);
13282 if (!SWIG_IsOK(ecode3)) {
13283 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13284 }
13285 arg3 = static_cast< int >(val3);
13286 }
13287 {
13288 PyThreadState* __tstate = wxPyBeginAllowThreads();
13289 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13290 wxPyEndAllowThreads(__tstate);
13291 if (PyErr_Occurred()) SWIG_fail;
13292 }
13293 {
13294 #if wxUSE_UNICODE
13295 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13296 #else
13297 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13298 #endif
13299 }
13300 {
13301 if (temp2)
13302 delete arg2;
13303 }
13304 return resultobj;
13305 fail:
13306 {
13307 if (temp2)
13308 delete arg2;
13309 }
13310 return NULL;
13311 }
13312
13313
13314 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13315 PyObject *resultobj = 0;
13316 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13317 wxString result;
13318 void *argp1 = 0 ;
13319 int res1 = 0 ;
13320 PyObject *swig_obj[1] ;
13321
13322 if (!args) SWIG_fail;
13323 swig_obj[0] = args;
13324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13325 if (!SWIG_IsOK(res1)) {
13326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13327 }
13328 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13329 {
13330 PyThreadState* __tstate = wxPyBeginAllowThreads();
13331 result = (arg1)->FindNext();
13332 wxPyEndAllowThreads(__tstate);
13333 if (PyErr_Occurred()) SWIG_fail;
13334 }
13335 {
13336 #if wxUSE_UNICODE
13337 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13338 #else
13339 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13340 #endif
13341 }
13342 return resultobj;
13343 fail:
13344 return NULL;
13345 }
13346
13347
13348 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13349 PyObject *resultobj = 0;
13350 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13351 int res1 = 0 ;
13352 PyObject * obj0 = 0 ;
13353 char * kwnames[] = {
13354 (char *) "handler", NULL
13355 };
13356
13357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13358 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13359 if (!SWIG_IsOK(res1)) {
13360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13361 }
13362 {
13363 PyThreadState* __tstate = wxPyBeginAllowThreads();
13364 wxFileSystem::AddHandler(arg1);
13365 wxPyEndAllowThreads(__tstate);
13366 if (PyErr_Occurred()) SWIG_fail;
13367 }
13368 resultobj = SWIG_Py_Void();
13369 return resultobj;
13370 fail:
13371 return NULL;
13372 }
13373
13374
13375 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13376 PyObject *resultobj = 0;
13377 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13378 wxFileSystemHandler *result = 0 ;
13379 void *argp1 = 0 ;
13380 int res1 = 0 ;
13381 PyObject * obj0 = 0 ;
13382 char * kwnames[] = {
13383 (char *) "handler", NULL
13384 };
13385
13386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13388 if (!SWIG_IsOK(res1)) {
13389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13390 }
13391 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13392 {
13393 PyThreadState* __tstate = wxPyBeginAllowThreads();
13394 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13395 wxPyEndAllowThreads(__tstate);
13396 if (PyErr_Occurred()) SWIG_fail;
13397 }
13398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13399 return resultobj;
13400 fail:
13401 return NULL;
13402 }
13403
13404
13405 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13406 PyObject *resultobj = 0;
13407
13408 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13409 {
13410 PyThreadState* __tstate = wxPyBeginAllowThreads();
13411 wxFileSystem::CleanUpHandlers();
13412 wxPyEndAllowThreads(__tstate);
13413 if (PyErr_Occurred()) SWIG_fail;
13414 }
13415 resultobj = SWIG_Py_Void();
13416 return resultobj;
13417 fail:
13418 return NULL;
13419 }
13420
13421
13422 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13423 PyObject *resultobj = 0;
13424 wxString *arg1 = 0 ;
13425 wxString result;
13426 bool temp1 = false ;
13427 PyObject * obj0 = 0 ;
13428 char * kwnames[] = {
13429 (char *) "filename", NULL
13430 };
13431
13432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13433 {
13434 arg1 = wxString_in_helper(obj0);
13435 if (arg1 == NULL) SWIG_fail;
13436 temp1 = true;
13437 }
13438 {
13439 PyThreadState* __tstate = wxPyBeginAllowThreads();
13440 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13441 wxPyEndAllowThreads(__tstate);
13442 if (PyErr_Occurred()) SWIG_fail;
13443 }
13444 {
13445 #if wxUSE_UNICODE
13446 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13447 #else
13448 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13449 #endif
13450 }
13451 {
13452 if (temp1)
13453 delete arg1;
13454 }
13455 return resultobj;
13456 fail:
13457 {
13458 if (temp1)
13459 delete arg1;
13460 }
13461 return NULL;
13462 }
13463
13464
13465 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13466 PyObject *resultobj = 0;
13467 wxString *arg1 = 0 ;
13468 wxString result;
13469 bool temp1 = false ;
13470 PyObject * obj0 = 0 ;
13471 char * kwnames[] = {
13472 (char *) "url", NULL
13473 };
13474
13475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13476 {
13477 arg1 = wxString_in_helper(obj0);
13478 if (arg1 == NULL) SWIG_fail;
13479 temp1 = true;
13480 }
13481 {
13482 PyThreadState* __tstate = wxPyBeginAllowThreads();
13483 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
13484 wxPyEndAllowThreads(__tstate);
13485 if (PyErr_Occurred()) SWIG_fail;
13486 }
13487 {
13488 #if wxUSE_UNICODE
13489 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13490 #else
13491 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13492 #endif
13493 }
13494 {
13495 if (temp1)
13496 delete arg1;
13497 }
13498 return resultobj;
13499 fail:
13500 {
13501 if (temp1)
13502 delete arg1;
13503 }
13504 return NULL;
13505 }
13506
13507
13508 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13509 PyObject *obj;
13510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13511 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13512 return SWIG_Py_Void();
13513 }
13514
13515 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13516 return SWIG_Python_InitShadowInstance(args);
13517 }
13518
13519 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13520 PyObject *resultobj = 0;
13521 wxInternetFSHandler *result = 0 ;
13522
13523 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13524 {
13525 PyThreadState* __tstate = wxPyBeginAllowThreads();
13526 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13527 wxPyEndAllowThreads(__tstate);
13528 if (PyErr_Occurred()) SWIG_fail;
13529 }
13530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13531 return resultobj;
13532 fail:
13533 return NULL;
13534 }
13535
13536
13537 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13538 PyObject *resultobj = 0;
13539 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13540 wxString *arg2 = 0 ;
13541 bool result;
13542 void *argp1 = 0 ;
13543 int res1 = 0 ;
13544 bool temp2 = false ;
13545 PyObject * obj0 = 0 ;
13546 PyObject * obj1 = 0 ;
13547 char * kwnames[] = {
13548 (char *) "self",(char *) "location", NULL
13549 };
13550
13551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13553 if (!SWIG_IsOK(res1)) {
13554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13555 }
13556 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13557 {
13558 arg2 = wxString_in_helper(obj1);
13559 if (arg2 == NULL) SWIG_fail;
13560 temp2 = true;
13561 }
13562 {
13563 PyThreadState* __tstate = wxPyBeginAllowThreads();
13564 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13565 wxPyEndAllowThreads(__tstate);
13566 if (PyErr_Occurred()) SWIG_fail;
13567 }
13568 {
13569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13570 }
13571 {
13572 if (temp2)
13573 delete arg2;
13574 }
13575 return resultobj;
13576 fail:
13577 {
13578 if (temp2)
13579 delete arg2;
13580 }
13581 return NULL;
13582 }
13583
13584
13585 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13586 PyObject *resultobj = 0;
13587 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13588 wxFileSystem *arg2 = 0 ;
13589 wxString *arg3 = 0 ;
13590 wxFSFile *result = 0 ;
13591 void *argp1 = 0 ;
13592 int res1 = 0 ;
13593 void *argp2 = 0 ;
13594 int res2 = 0 ;
13595 bool temp3 = false ;
13596 PyObject * obj0 = 0 ;
13597 PyObject * obj1 = 0 ;
13598 PyObject * obj2 = 0 ;
13599 char * kwnames[] = {
13600 (char *) "self",(char *) "fs",(char *) "location", NULL
13601 };
13602
13603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13605 if (!SWIG_IsOK(res1)) {
13606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13607 }
13608 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13609 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13610 if (!SWIG_IsOK(res2)) {
13611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13612 }
13613 if (!argp2) {
13614 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13615 }
13616 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13617 {
13618 arg3 = wxString_in_helper(obj2);
13619 if (arg3 == NULL) SWIG_fail;
13620 temp3 = true;
13621 }
13622 {
13623 PyThreadState* __tstate = wxPyBeginAllowThreads();
13624 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13625 wxPyEndAllowThreads(__tstate);
13626 if (PyErr_Occurred()) SWIG_fail;
13627 }
13628 {
13629 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13630 }
13631 {
13632 if (temp3)
13633 delete arg3;
13634 }
13635 return resultobj;
13636 fail:
13637 {
13638 if (temp3)
13639 delete arg3;
13640 }
13641 return NULL;
13642 }
13643
13644
13645 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13646 PyObject *obj;
13647 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13648 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13649 return SWIG_Py_Void();
13650 }
13651
13652 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13653 return SWIG_Python_InitShadowInstance(args);
13654 }
13655
13656 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13657 PyObject *resultobj = 0;
13658 wxZipFSHandler *result = 0 ;
13659
13660 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13661 {
13662 PyThreadState* __tstate = wxPyBeginAllowThreads();
13663 result = (wxZipFSHandler *)new wxZipFSHandler();
13664 wxPyEndAllowThreads(__tstate);
13665 if (PyErr_Occurred()) SWIG_fail;
13666 }
13667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13668 return resultobj;
13669 fail:
13670 return NULL;
13671 }
13672
13673
13674 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13675 PyObject *resultobj = 0;
13676 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13677 wxString *arg2 = 0 ;
13678 bool result;
13679 void *argp1 = 0 ;
13680 int res1 = 0 ;
13681 bool temp2 = false ;
13682 PyObject * obj0 = 0 ;
13683 PyObject * obj1 = 0 ;
13684 char * kwnames[] = {
13685 (char *) "self",(char *) "location", NULL
13686 };
13687
13688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13690 if (!SWIG_IsOK(res1)) {
13691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13692 }
13693 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13694 {
13695 arg2 = wxString_in_helper(obj1);
13696 if (arg2 == NULL) SWIG_fail;
13697 temp2 = true;
13698 }
13699 {
13700 PyThreadState* __tstate = wxPyBeginAllowThreads();
13701 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13702 wxPyEndAllowThreads(__tstate);
13703 if (PyErr_Occurred()) SWIG_fail;
13704 }
13705 {
13706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13707 }
13708 {
13709 if (temp2)
13710 delete arg2;
13711 }
13712 return resultobj;
13713 fail:
13714 {
13715 if (temp2)
13716 delete arg2;
13717 }
13718 return NULL;
13719 }
13720
13721
13722 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13723 PyObject *resultobj = 0;
13724 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13725 wxFileSystem *arg2 = 0 ;
13726 wxString *arg3 = 0 ;
13727 wxFSFile *result = 0 ;
13728 void *argp1 = 0 ;
13729 int res1 = 0 ;
13730 void *argp2 = 0 ;
13731 int res2 = 0 ;
13732 bool temp3 = false ;
13733 PyObject * obj0 = 0 ;
13734 PyObject * obj1 = 0 ;
13735 PyObject * obj2 = 0 ;
13736 char * kwnames[] = {
13737 (char *) "self",(char *) "fs",(char *) "location", NULL
13738 };
13739
13740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13742 if (!SWIG_IsOK(res1)) {
13743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13744 }
13745 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13746 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13747 if (!SWIG_IsOK(res2)) {
13748 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13749 }
13750 if (!argp2) {
13751 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13752 }
13753 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13754 {
13755 arg3 = wxString_in_helper(obj2);
13756 if (arg3 == NULL) SWIG_fail;
13757 temp3 = true;
13758 }
13759 {
13760 PyThreadState* __tstate = wxPyBeginAllowThreads();
13761 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13762 wxPyEndAllowThreads(__tstate);
13763 if (PyErr_Occurred()) SWIG_fail;
13764 }
13765 {
13766 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13767 }
13768 {
13769 if (temp3)
13770 delete arg3;
13771 }
13772 return resultobj;
13773 fail:
13774 {
13775 if (temp3)
13776 delete arg3;
13777 }
13778 return NULL;
13779 }
13780
13781
13782 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13783 PyObject *resultobj = 0;
13784 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13785 wxString *arg2 = 0 ;
13786 int arg3 = (int) 0 ;
13787 wxString result;
13788 void *argp1 = 0 ;
13789 int res1 = 0 ;
13790 bool temp2 = false ;
13791 int val3 ;
13792 int ecode3 = 0 ;
13793 PyObject * obj0 = 0 ;
13794 PyObject * obj1 = 0 ;
13795 PyObject * obj2 = 0 ;
13796 char * kwnames[] = {
13797 (char *) "self",(char *) "spec",(char *) "flags", NULL
13798 };
13799
13800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13802 if (!SWIG_IsOK(res1)) {
13803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13804 }
13805 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13806 {
13807 arg2 = wxString_in_helper(obj1);
13808 if (arg2 == NULL) SWIG_fail;
13809 temp2 = true;
13810 }
13811 if (obj2) {
13812 ecode3 = SWIG_AsVal_int(obj2, &val3);
13813 if (!SWIG_IsOK(ecode3)) {
13814 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13815 }
13816 arg3 = static_cast< int >(val3);
13817 }
13818 {
13819 PyThreadState* __tstate = wxPyBeginAllowThreads();
13820 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13821 wxPyEndAllowThreads(__tstate);
13822 if (PyErr_Occurred()) SWIG_fail;
13823 }
13824 {
13825 #if wxUSE_UNICODE
13826 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13827 #else
13828 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13829 #endif
13830 }
13831 {
13832 if (temp2)
13833 delete arg2;
13834 }
13835 return resultobj;
13836 fail:
13837 {
13838 if (temp2)
13839 delete arg2;
13840 }
13841 return NULL;
13842 }
13843
13844
13845 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13846 PyObject *resultobj = 0;
13847 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13848 wxString result;
13849 void *argp1 = 0 ;
13850 int res1 = 0 ;
13851 PyObject *swig_obj[1] ;
13852
13853 if (!args) SWIG_fail;
13854 swig_obj[0] = args;
13855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13856 if (!SWIG_IsOK(res1)) {
13857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13858 }
13859 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13860 {
13861 PyThreadState* __tstate = wxPyBeginAllowThreads();
13862 result = (arg1)->FindNext();
13863 wxPyEndAllowThreads(__tstate);
13864 if (PyErr_Occurred()) SWIG_fail;
13865 }
13866 {
13867 #if wxUSE_UNICODE
13868 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13869 #else
13870 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13871 #endif
13872 }
13873 return resultobj;
13874 fail:
13875 return NULL;
13876 }
13877
13878
13879 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13880 PyObject *obj;
13881 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13882 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13883 return SWIG_Py_Void();
13884 }
13885
13886 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13887 return SWIG_Python_InitShadowInstance(args);
13888 }
13889
13890 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13891 PyObject *resultobj = 0;
13892 wxString *arg1 = 0 ;
13893 wxImage *arg2 = 0 ;
13894 long arg3 ;
13895 bool temp1 = false ;
13896 void *argp2 = 0 ;
13897 int res2 = 0 ;
13898 long val3 ;
13899 int ecode3 = 0 ;
13900 PyObject * obj0 = 0 ;
13901 PyObject * obj1 = 0 ;
13902 PyObject * obj2 = 0 ;
13903 char * kwnames[] = {
13904 (char *) "filename",(char *) "image",(char *) "type", NULL
13905 };
13906
13907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13908 {
13909 arg1 = wxString_in_helper(obj0);
13910 if (arg1 == NULL) SWIG_fail;
13911 temp1 = true;
13912 }
13913 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13914 if (!SWIG_IsOK(res2)) {
13915 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13916 }
13917 if (!argp2) {
13918 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13919 }
13920 arg2 = reinterpret_cast< wxImage * >(argp2);
13921 ecode3 = SWIG_AsVal_long(obj2, &val3);
13922 if (!SWIG_IsOK(ecode3)) {
13923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13924 }
13925 arg3 = static_cast< long >(val3);
13926 {
13927 PyThreadState* __tstate = wxPyBeginAllowThreads();
13928 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13929 wxPyEndAllowThreads(__tstate);
13930 if (PyErr_Occurred()) SWIG_fail;
13931 }
13932 resultobj = SWIG_Py_Void();
13933 {
13934 if (temp1)
13935 delete arg1;
13936 }
13937 return resultobj;
13938 fail:
13939 {
13940 if (temp1)
13941 delete arg1;
13942 }
13943 return NULL;
13944 }
13945
13946
13947 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13948 PyObject *resultobj = 0;
13949 wxString *arg1 = 0 ;
13950 wxBitmap *arg2 = 0 ;
13951 long arg3 ;
13952 bool temp1 = false ;
13953 void *argp2 = 0 ;
13954 int res2 = 0 ;
13955 long val3 ;
13956 int ecode3 = 0 ;
13957 PyObject * obj0 = 0 ;
13958 PyObject * obj1 = 0 ;
13959 PyObject * obj2 = 0 ;
13960 char * kwnames[] = {
13961 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13962 };
13963
13964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13965 {
13966 arg1 = wxString_in_helper(obj0);
13967 if (arg1 == NULL) SWIG_fail;
13968 temp1 = true;
13969 }
13970 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13971 if (!SWIG_IsOK(res2)) {
13972 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13973 }
13974 if (!argp2) {
13975 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13976 }
13977 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13978 ecode3 = SWIG_AsVal_long(obj2, &val3);
13979 if (!SWIG_IsOK(ecode3)) {
13980 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13981 }
13982 arg3 = static_cast< long >(val3);
13983 {
13984 PyThreadState* __tstate = wxPyBeginAllowThreads();
13985 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
13986 wxPyEndAllowThreads(__tstate);
13987 if (PyErr_Occurred()) SWIG_fail;
13988 }
13989 resultobj = SWIG_Py_Void();
13990 {
13991 if (temp1)
13992 delete arg1;
13993 }
13994 return resultobj;
13995 fail:
13996 {
13997 if (temp1)
13998 delete arg1;
13999 }
14000 return NULL;
14001 }
14002
14003
14004 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14005 PyObject *resultobj = 0;
14006 wxString *arg1 = 0 ;
14007 PyObject *arg2 = (PyObject *) 0 ;
14008 bool temp1 = false ;
14009 PyObject * obj0 = 0 ;
14010 PyObject * obj1 = 0 ;
14011 char * kwnames[] = {
14012 (char *) "filename",(char *) "data", NULL
14013 };
14014
14015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
14016 {
14017 arg1 = wxString_in_helper(obj0);
14018 if (arg1 == NULL) SWIG_fail;
14019 temp1 = true;
14020 }
14021 arg2 = obj1;
14022 {
14023 PyThreadState* __tstate = wxPyBeginAllowThreads();
14024 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
14025 wxPyEndAllowThreads(__tstate);
14026 if (PyErr_Occurred()) SWIG_fail;
14027 }
14028 resultobj = SWIG_Py_Void();
14029 {
14030 if (temp1)
14031 delete arg1;
14032 }
14033 return resultobj;
14034 fail:
14035 {
14036 if (temp1)
14037 delete arg1;
14038 }
14039 return NULL;
14040 }
14041
14042
14043 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14044 PyObject *resultobj = 0;
14045 wxMemoryFSHandler *result = 0 ;
14046
14047 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
14048 {
14049 PyThreadState* __tstate = wxPyBeginAllowThreads();
14050 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
14051 wxPyEndAllowThreads(__tstate);
14052 if (PyErr_Occurred()) SWIG_fail;
14053 }
14054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
14055 return resultobj;
14056 fail:
14057 return NULL;
14058 }
14059
14060
14061 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14062 PyObject *resultobj = 0;
14063 wxString *arg1 = 0 ;
14064 bool temp1 = false ;
14065 PyObject * obj0 = 0 ;
14066 char * kwnames[] = {
14067 (char *) "filename", NULL
14068 };
14069
14070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14071 {
14072 arg1 = wxString_in_helper(obj0);
14073 if (arg1 == NULL) SWIG_fail;
14074 temp1 = true;
14075 }
14076 {
14077 PyThreadState* __tstate = wxPyBeginAllowThreads();
14078 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14079 wxPyEndAllowThreads(__tstate);
14080 if (PyErr_Occurred()) SWIG_fail;
14081 }
14082 resultobj = SWIG_Py_Void();
14083 {
14084 if (temp1)
14085 delete arg1;
14086 }
14087 return resultobj;
14088 fail:
14089 {
14090 if (temp1)
14091 delete arg1;
14092 }
14093 return NULL;
14094 }
14095
14096
14097 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14098 PyObject *resultobj = 0;
14099 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14100 wxString *arg2 = 0 ;
14101 bool result;
14102 void *argp1 = 0 ;
14103 int res1 = 0 ;
14104 bool temp2 = false ;
14105 PyObject * obj0 = 0 ;
14106 PyObject * obj1 = 0 ;
14107 char * kwnames[] = {
14108 (char *) "self",(char *) "location", NULL
14109 };
14110
14111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14113 if (!SWIG_IsOK(res1)) {
14114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14115 }
14116 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14117 {
14118 arg2 = wxString_in_helper(obj1);
14119 if (arg2 == NULL) SWIG_fail;
14120 temp2 = true;
14121 }
14122 {
14123 PyThreadState* __tstate = wxPyBeginAllowThreads();
14124 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14125 wxPyEndAllowThreads(__tstate);
14126 if (PyErr_Occurred()) SWIG_fail;
14127 }
14128 {
14129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14130 }
14131 {
14132 if (temp2)
14133 delete arg2;
14134 }
14135 return resultobj;
14136 fail:
14137 {
14138 if (temp2)
14139 delete arg2;
14140 }
14141 return NULL;
14142 }
14143
14144
14145 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14146 PyObject *resultobj = 0;
14147 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14148 wxFileSystem *arg2 = 0 ;
14149 wxString *arg3 = 0 ;
14150 wxFSFile *result = 0 ;
14151 void *argp1 = 0 ;
14152 int res1 = 0 ;
14153 void *argp2 = 0 ;
14154 int res2 = 0 ;
14155 bool temp3 = false ;
14156 PyObject * obj0 = 0 ;
14157 PyObject * obj1 = 0 ;
14158 PyObject * obj2 = 0 ;
14159 char * kwnames[] = {
14160 (char *) "self",(char *) "fs",(char *) "location", NULL
14161 };
14162
14163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14165 if (!SWIG_IsOK(res1)) {
14166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14167 }
14168 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14169 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14170 if (!SWIG_IsOK(res2)) {
14171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14172 }
14173 if (!argp2) {
14174 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14175 }
14176 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14177 {
14178 arg3 = wxString_in_helper(obj2);
14179 if (arg3 == NULL) SWIG_fail;
14180 temp3 = true;
14181 }
14182 {
14183 PyThreadState* __tstate = wxPyBeginAllowThreads();
14184 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14185 wxPyEndAllowThreads(__tstate);
14186 if (PyErr_Occurred()) SWIG_fail;
14187 }
14188 {
14189 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14190 }
14191 {
14192 if (temp3)
14193 delete arg3;
14194 }
14195 return resultobj;
14196 fail:
14197 {
14198 if (temp3)
14199 delete arg3;
14200 }
14201 return NULL;
14202 }
14203
14204
14205 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14206 PyObject *resultobj = 0;
14207 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14208 wxString *arg2 = 0 ;
14209 int arg3 = (int) 0 ;
14210 wxString result;
14211 void *argp1 = 0 ;
14212 int res1 = 0 ;
14213 bool temp2 = false ;
14214 int val3 ;
14215 int ecode3 = 0 ;
14216 PyObject * obj0 = 0 ;
14217 PyObject * obj1 = 0 ;
14218 PyObject * obj2 = 0 ;
14219 char * kwnames[] = {
14220 (char *) "self",(char *) "spec",(char *) "flags", NULL
14221 };
14222
14223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14225 if (!SWIG_IsOK(res1)) {
14226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14227 }
14228 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14229 {
14230 arg2 = wxString_in_helper(obj1);
14231 if (arg2 == NULL) SWIG_fail;
14232 temp2 = true;
14233 }
14234 if (obj2) {
14235 ecode3 = SWIG_AsVal_int(obj2, &val3);
14236 if (!SWIG_IsOK(ecode3)) {
14237 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14238 }
14239 arg3 = static_cast< int >(val3);
14240 }
14241 {
14242 PyThreadState* __tstate = wxPyBeginAllowThreads();
14243 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14244 wxPyEndAllowThreads(__tstate);
14245 if (PyErr_Occurred()) SWIG_fail;
14246 }
14247 {
14248 #if wxUSE_UNICODE
14249 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14250 #else
14251 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14252 #endif
14253 }
14254 {
14255 if (temp2)
14256 delete arg2;
14257 }
14258 return resultobj;
14259 fail:
14260 {
14261 if (temp2)
14262 delete arg2;
14263 }
14264 return NULL;
14265 }
14266
14267
14268 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14269 PyObject *resultobj = 0;
14270 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14271 wxString result;
14272 void *argp1 = 0 ;
14273 int res1 = 0 ;
14274 PyObject *swig_obj[1] ;
14275
14276 if (!args) SWIG_fail;
14277 swig_obj[0] = args;
14278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14279 if (!SWIG_IsOK(res1)) {
14280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14281 }
14282 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14283 {
14284 PyThreadState* __tstate = wxPyBeginAllowThreads();
14285 result = (arg1)->FindNext();
14286 wxPyEndAllowThreads(__tstate);
14287 if (PyErr_Occurred()) SWIG_fail;
14288 }
14289 {
14290 #if wxUSE_UNICODE
14291 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14292 #else
14293 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14294 #endif
14295 }
14296 return resultobj;
14297 fail:
14298 return NULL;
14299 }
14300
14301
14302 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14303 PyObject *obj;
14304 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14305 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14306 return SWIG_Py_Void();
14307 }
14308
14309 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14310 return SWIG_Python_InitShadowInstance(args);
14311 }
14312
14313 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14314 PyObject *resultobj = 0;
14315 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14316 wxString result;
14317 void *argp1 = 0 ;
14318 int res1 = 0 ;
14319 PyObject *swig_obj[1] ;
14320
14321 if (!args) SWIG_fail;
14322 swig_obj[0] = args;
14323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14324 if (!SWIG_IsOK(res1)) {
14325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14326 }
14327 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14328 {
14329 PyThreadState* __tstate = wxPyBeginAllowThreads();
14330 result = (arg1)->GetName();
14331 wxPyEndAllowThreads(__tstate);
14332 if (PyErr_Occurred()) SWIG_fail;
14333 }
14334 {
14335 #if wxUSE_UNICODE
14336 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14337 #else
14338 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14339 #endif
14340 }
14341 return resultobj;
14342 fail:
14343 return NULL;
14344 }
14345
14346
14347 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14348 PyObject *resultobj = 0;
14349 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14350 wxString result;
14351 void *argp1 = 0 ;
14352 int res1 = 0 ;
14353 PyObject *swig_obj[1] ;
14354
14355 if (!args) SWIG_fail;
14356 swig_obj[0] = args;
14357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14358 if (!SWIG_IsOK(res1)) {
14359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14360 }
14361 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14362 {
14363 PyThreadState* __tstate = wxPyBeginAllowThreads();
14364 result = (arg1)->GetExtension();
14365 wxPyEndAllowThreads(__tstate);
14366 if (PyErr_Occurred()) SWIG_fail;
14367 }
14368 {
14369 #if wxUSE_UNICODE
14370 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14371 #else
14372 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14373 #endif
14374 }
14375 return resultobj;
14376 fail:
14377 return NULL;
14378 }
14379
14380
14381 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14382 PyObject *resultobj = 0;
14383 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14384 long result;
14385 void *argp1 = 0 ;
14386 int res1 = 0 ;
14387 PyObject *swig_obj[1] ;
14388
14389 if (!args) SWIG_fail;
14390 swig_obj[0] = args;
14391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14392 if (!SWIG_IsOK(res1)) {
14393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14394 }
14395 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14396 {
14397 PyThreadState* __tstate = wxPyBeginAllowThreads();
14398 result = (long)(arg1)->GetType();
14399 wxPyEndAllowThreads(__tstate);
14400 if (PyErr_Occurred()) SWIG_fail;
14401 }
14402 resultobj = SWIG_From_long(static_cast< long >(result));
14403 return resultobj;
14404 fail:
14405 return NULL;
14406 }
14407
14408
14409 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14410 PyObject *resultobj = 0;
14411 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14412 wxString result;
14413 void *argp1 = 0 ;
14414 int res1 = 0 ;
14415 PyObject *swig_obj[1] ;
14416
14417 if (!args) SWIG_fail;
14418 swig_obj[0] = args;
14419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14420 if (!SWIG_IsOK(res1)) {
14421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14422 }
14423 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14424 {
14425 PyThreadState* __tstate = wxPyBeginAllowThreads();
14426 result = (arg1)->GetMimeType();
14427 wxPyEndAllowThreads(__tstate);
14428 if (PyErr_Occurred()) SWIG_fail;
14429 }
14430 {
14431 #if wxUSE_UNICODE
14432 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14433 #else
14434 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14435 #endif
14436 }
14437 return resultobj;
14438 fail:
14439 return NULL;
14440 }
14441
14442
14443 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14444 PyObject *resultobj = 0;
14445 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14446 wxString *arg2 = 0 ;
14447 bool result;
14448 void *argp1 = 0 ;
14449 int res1 = 0 ;
14450 bool temp2 = false ;
14451 PyObject * obj0 = 0 ;
14452 PyObject * obj1 = 0 ;
14453 char * kwnames[] = {
14454 (char *) "self",(char *) "name", NULL
14455 };
14456
14457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14459 if (!SWIG_IsOK(res1)) {
14460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14461 }
14462 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14463 {
14464 arg2 = wxString_in_helper(obj1);
14465 if (arg2 == NULL) SWIG_fail;
14466 temp2 = true;
14467 }
14468 {
14469 PyThreadState* __tstate = wxPyBeginAllowThreads();
14470 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14471 wxPyEndAllowThreads(__tstate);
14472 if (PyErr_Occurred()) SWIG_fail;
14473 }
14474 {
14475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14476 }
14477 {
14478 if (temp2)
14479 delete arg2;
14480 }
14481 return resultobj;
14482 fail:
14483 {
14484 if (temp2)
14485 delete arg2;
14486 }
14487 return NULL;
14488 }
14489
14490
14491 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14492 PyObject *resultobj = 0;
14493 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14494 wxInputStream *arg2 = 0 ;
14495 bool result;
14496 void *argp1 = 0 ;
14497 int res1 = 0 ;
14498 wxPyInputStream *temp2 ;
14499 bool created2 ;
14500 PyObject * obj0 = 0 ;
14501 PyObject * obj1 = 0 ;
14502 char * kwnames[] = {
14503 (char *) "self",(char *) "stream", NULL
14504 };
14505
14506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14508 if (!SWIG_IsOK(res1)) {
14509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14510 }
14511 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14512 {
14513 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14514 arg2 = temp2->m_wxis;
14515 created2 = false;
14516 } else {
14517 PyErr_Clear(); // clear the failure of the wxPyConvert above
14518 arg2 = wxPyCBInputStream_create(obj1, false);
14519 if (arg2 == NULL) {
14520 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14521 SWIG_fail;
14522 }
14523 created2 = true;
14524 }
14525 }
14526 {
14527 PyThreadState* __tstate = wxPyBeginAllowThreads();
14528 result = (bool)(arg1)->CanRead(*arg2);
14529 wxPyEndAllowThreads(__tstate);
14530 if (PyErr_Occurred()) SWIG_fail;
14531 }
14532 {
14533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14534 }
14535 {
14536 if (created2) delete arg2;
14537 }
14538 return resultobj;
14539 fail:
14540 {
14541 if (created2) delete arg2;
14542 }
14543 return NULL;
14544 }
14545
14546
14547 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14548 PyObject *resultobj = 0;
14549 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14550 wxString *arg2 = 0 ;
14551 void *argp1 = 0 ;
14552 int res1 = 0 ;
14553 bool temp2 = false ;
14554 PyObject * obj0 = 0 ;
14555 PyObject * obj1 = 0 ;
14556 char * kwnames[] = {
14557 (char *) "self",(char *) "name", NULL
14558 };
14559
14560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14562 if (!SWIG_IsOK(res1)) {
14563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14564 }
14565 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14566 {
14567 arg2 = wxString_in_helper(obj1);
14568 if (arg2 == NULL) SWIG_fail;
14569 temp2 = true;
14570 }
14571 {
14572 PyThreadState* __tstate = wxPyBeginAllowThreads();
14573 (arg1)->SetName((wxString const &)*arg2);
14574 wxPyEndAllowThreads(__tstate);
14575 if (PyErr_Occurred()) SWIG_fail;
14576 }
14577 resultobj = SWIG_Py_Void();
14578 {
14579 if (temp2)
14580 delete arg2;
14581 }
14582 return resultobj;
14583 fail:
14584 {
14585 if (temp2)
14586 delete arg2;
14587 }
14588 return NULL;
14589 }
14590
14591
14592 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14593 PyObject *resultobj = 0;
14594 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14595 wxString *arg2 = 0 ;
14596 void *argp1 = 0 ;
14597 int res1 = 0 ;
14598 bool temp2 = false ;
14599 PyObject * obj0 = 0 ;
14600 PyObject * obj1 = 0 ;
14601 char * kwnames[] = {
14602 (char *) "self",(char *) "extension", NULL
14603 };
14604
14605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
14606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14607 if (!SWIG_IsOK(res1)) {
14608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14609 }
14610 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14611 {
14612 arg2 = wxString_in_helper(obj1);
14613 if (arg2 == NULL) SWIG_fail;
14614 temp2 = true;
14615 }
14616 {
14617 PyThreadState* __tstate = wxPyBeginAllowThreads();
14618 (arg1)->SetExtension((wxString const &)*arg2);
14619 wxPyEndAllowThreads(__tstate);
14620 if (PyErr_Occurred()) SWIG_fail;
14621 }
14622 resultobj = SWIG_Py_Void();
14623 {
14624 if (temp2)
14625 delete arg2;
14626 }
14627 return resultobj;
14628 fail:
14629 {
14630 if (temp2)
14631 delete arg2;
14632 }
14633 return NULL;
14634 }
14635
14636
14637 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14638 PyObject *resultobj = 0;
14639 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14640 long arg2 ;
14641 void *argp1 = 0 ;
14642 int res1 = 0 ;
14643 long val2 ;
14644 int ecode2 = 0 ;
14645 PyObject * obj0 = 0 ;
14646 PyObject * obj1 = 0 ;
14647 char * kwnames[] = {
14648 (char *) "self",(char *) "type", NULL
14649 };
14650
14651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14653 if (!SWIG_IsOK(res1)) {
14654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14655 }
14656 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14657 ecode2 = SWIG_AsVal_long(obj1, &val2);
14658 if (!SWIG_IsOK(ecode2)) {
14659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14660 }
14661 arg2 = static_cast< long >(val2);
14662 {
14663 PyThreadState* __tstate = wxPyBeginAllowThreads();
14664 (arg1)->SetType(arg2);
14665 wxPyEndAllowThreads(__tstate);
14666 if (PyErr_Occurred()) SWIG_fail;
14667 }
14668 resultobj = SWIG_Py_Void();
14669 return resultobj;
14670 fail:
14671 return NULL;
14672 }
14673
14674
14675 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14676 PyObject *resultobj = 0;
14677 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14678 wxString *arg2 = 0 ;
14679 void *argp1 = 0 ;
14680 int res1 = 0 ;
14681 bool temp2 = false ;
14682 PyObject * obj0 = 0 ;
14683 PyObject * obj1 = 0 ;
14684 char * kwnames[] = {
14685 (char *) "self",(char *) "mimetype", NULL
14686 };
14687
14688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14690 if (!SWIG_IsOK(res1)) {
14691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14692 }
14693 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14694 {
14695 arg2 = wxString_in_helper(obj1);
14696 if (arg2 == NULL) SWIG_fail;
14697 temp2 = true;
14698 }
14699 {
14700 PyThreadState* __tstate = wxPyBeginAllowThreads();
14701 (arg1)->SetMimeType((wxString const &)*arg2);
14702 wxPyEndAllowThreads(__tstate);
14703 if (PyErr_Occurred()) SWIG_fail;
14704 }
14705 resultobj = SWIG_Py_Void();
14706 {
14707 if (temp2)
14708 delete arg2;
14709 }
14710 return resultobj;
14711 fail:
14712 {
14713 if (temp2)
14714 delete arg2;
14715 }
14716 return NULL;
14717 }
14718
14719
14720 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14721 PyObject *obj;
14722 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14723 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14724 return SWIG_Py_Void();
14725 }
14726
14727 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14728 PyObject *resultobj = 0;
14729 wxPyImageHandler *result = 0 ;
14730
14731 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14732 {
14733 PyThreadState* __tstate = wxPyBeginAllowThreads();
14734 result = (wxPyImageHandler *)new wxPyImageHandler();
14735 wxPyEndAllowThreads(__tstate);
14736 if (PyErr_Occurred()) SWIG_fail;
14737 }
14738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14739 return resultobj;
14740 fail:
14741 return NULL;
14742 }
14743
14744
14745 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14746 PyObject *resultobj = 0;
14747 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14748 PyObject *arg2 = (PyObject *) 0 ;
14749 void *argp1 = 0 ;
14750 int res1 = 0 ;
14751 PyObject * obj0 = 0 ;
14752 PyObject * obj1 = 0 ;
14753 char * kwnames[] = {
14754 (char *) "self",(char *) "self", NULL
14755 };
14756
14757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14759 if (!SWIG_IsOK(res1)) {
14760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14761 }
14762 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14763 arg2 = obj1;
14764 {
14765 PyThreadState* __tstate = wxPyBeginAllowThreads();
14766 (arg1)->_SetSelf(arg2);
14767 wxPyEndAllowThreads(__tstate);
14768 if (PyErr_Occurred()) SWIG_fail;
14769 }
14770 resultobj = SWIG_Py_Void();
14771 return resultobj;
14772 fail:
14773 return NULL;
14774 }
14775
14776
14777 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14778 PyObject *obj;
14779 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14780 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14781 return SWIG_Py_Void();
14782 }
14783
14784 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14785 return SWIG_Python_InitShadowInstance(args);
14786 }
14787
14788 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14789 PyObject *resultobj = 0;
14790 wxImageHistogram *result = 0 ;
14791
14792 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14793 {
14794 PyThreadState* __tstate = wxPyBeginAllowThreads();
14795 result = (wxImageHistogram *)new wxImageHistogram();
14796 wxPyEndAllowThreads(__tstate);
14797 if (PyErr_Occurred()) SWIG_fail;
14798 }
14799 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14800 return resultobj;
14801 fail:
14802 return NULL;
14803 }
14804
14805
14806 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14807 PyObject *resultobj = 0;
14808 byte arg1 ;
14809 byte arg2 ;
14810 byte arg3 ;
14811 unsigned long result;
14812 unsigned char val1 ;
14813 int ecode1 = 0 ;
14814 unsigned char val2 ;
14815 int ecode2 = 0 ;
14816 unsigned char val3 ;
14817 int ecode3 = 0 ;
14818 PyObject * obj0 = 0 ;
14819 PyObject * obj1 = 0 ;
14820 PyObject * obj2 = 0 ;
14821 char * kwnames[] = {
14822 (char *) "r",(char *) "g",(char *) "b", NULL
14823 };
14824
14825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14826 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14827 if (!SWIG_IsOK(ecode1)) {
14828 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14829 }
14830 arg1 = static_cast< byte >(val1);
14831 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14832 if (!SWIG_IsOK(ecode2)) {
14833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14834 }
14835 arg2 = static_cast< byte >(val2);
14836 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14837 if (!SWIG_IsOK(ecode3)) {
14838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14839 }
14840 arg3 = static_cast< byte >(val3);
14841 {
14842 PyThreadState* __tstate = wxPyBeginAllowThreads();
14843 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14844 wxPyEndAllowThreads(__tstate);
14845 if (PyErr_Occurred()) SWIG_fail;
14846 }
14847 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14848 return resultobj;
14849 fail:
14850 return NULL;
14851 }
14852
14853
14854 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14855 PyObject *resultobj = 0;
14856 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14857 byte *arg2 = (byte *) 0 ;
14858 byte *arg3 = (byte *) 0 ;
14859 byte *arg4 = (byte *) 0 ;
14860 byte arg5 = (byte) 1 ;
14861 byte arg6 = (byte) 0 ;
14862 byte arg7 = (byte) 0 ;
14863 bool result;
14864 void *argp1 = 0 ;
14865 int res1 = 0 ;
14866 byte temp2 ;
14867 int res2 = SWIG_TMPOBJ ;
14868 byte temp3 ;
14869 int res3 = SWIG_TMPOBJ ;
14870 byte temp4 ;
14871 int res4 = SWIG_TMPOBJ ;
14872 unsigned char val5 ;
14873 int ecode5 = 0 ;
14874 unsigned char val6 ;
14875 int ecode6 = 0 ;
14876 unsigned char val7 ;
14877 int ecode7 = 0 ;
14878 PyObject * obj0 = 0 ;
14879 PyObject * obj1 = 0 ;
14880 PyObject * obj2 = 0 ;
14881 PyObject * obj3 = 0 ;
14882 char * kwnames[] = {
14883 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14884 };
14885
14886 arg2 = &temp2;
14887 arg3 = &temp3;
14888 arg4 = &temp4;
14889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14891 if (!SWIG_IsOK(res1)) {
14892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14893 }
14894 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14895 if (obj1) {
14896 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14897 if (!SWIG_IsOK(ecode5)) {
14898 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14899 }
14900 arg5 = static_cast< byte >(val5);
14901 }
14902 if (obj2) {
14903 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14904 if (!SWIG_IsOK(ecode6)) {
14905 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14906 }
14907 arg6 = static_cast< byte >(val6);
14908 }
14909 if (obj3) {
14910 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14911 if (!SWIG_IsOK(ecode7)) {
14912 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14913 }
14914 arg7 = static_cast< byte >(val7);
14915 }
14916 {
14917 PyThreadState* __tstate = wxPyBeginAllowThreads();
14918 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14919 wxPyEndAllowThreads(__tstate);
14920 if (PyErr_Occurred()) SWIG_fail;
14921 }
14922 {
14923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14924 }
14925 if (SWIG_IsTmpObj(res2)) {
14926 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14927 } else {
14928 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14929 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14930 }
14931 if (SWIG_IsTmpObj(res3)) {
14932 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14933 } else {
14934 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14935 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14936 }
14937 if (SWIG_IsTmpObj(res4)) {
14938 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14939 } else {
14940 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14941 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14942 }
14943 return resultobj;
14944 fail:
14945 return NULL;
14946 }
14947
14948
14949 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14950 PyObject *resultobj = 0;
14951 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14952 unsigned long arg2 ;
14953 unsigned long result;
14954 void *argp1 = 0 ;
14955 int res1 = 0 ;
14956 unsigned long val2 ;
14957 int ecode2 = 0 ;
14958 PyObject * obj0 = 0 ;
14959 PyObject * obj1 = 0 ;
14960 char * kwnames[] = {
14961 (char *) "self",(char *) "key", NULL
14962 };
14963
14964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14966 if (!SWIG_IsOK(res1)) {
14967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14968 }
14969 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14970 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14971 if (!SWIG_IsOK(ecode2)) {
14972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14973 }
14974 arg2 = static_cast< unsigned long >(val2);
14975 {
14976 PyThreadState* __tstate = wxPyBeginAllowThreads();
14977 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14978 wxPyEndAllowThreads(__tstate);
14979 if (PyErr_Occurred()) SWIG_fail;
14980 }
14981 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14982 return resultobj;
14983 fail:
14984 return NULL;
14985 }
14986
14987
14988 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14989 PyObject *resultobj = 0;
14990 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14991 byte arg2 ;
14992 byte arg3 ;
14993 byte arg4 ;
14994 unsigned long result;
14995 void *argp1 = 0 ;
14996 int res1 = 0 ;
14997 unsigned char val2 ;
14998 int ecode2 = 0 ;
14999 unsigned char val3 ;
15000 int ecode3 = 0 ;
15001 unsigned char val4 ;
15002 int ecode4 = 0 ;
15003 PyObject * obj0 = 0 ;
15004 PyObject * obj1 = 0 ;
15005 PyObject * obj2 = 0 ;
15006 PyObject * obj3 = 0 ;
15007 char * kwnames[] = {
15008 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15009 };
15010
15011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15013 if (!SWIG_IsOK(res1)) {
15014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15015 }
15016 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15017 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15018 if (!SWIG_IsOK(ecode2)) {
15019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
15020 }
15021 arg2 = static_cast< byte >(val2);
15022 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15023 if (!SWIG_IsOK(ecode3)) {
15024 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
15025 }
15026 arg3 = static_cast< byte >(val3);
15027 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15028 if (!SWIG_IsOK(ecode4)) {
15029 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
15030 }
15031 arg4 = static_cast< byte >(val4);
15032 {
15033 PyThreadState* __tstate = wxPyBeginAllowThreads();
15034 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
15035 wxPyEndAllowThreads(__tstate);
15036 if (PyErr_Occurred()) SWIG_fail;
15037 }
15038 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15039 return resultobj;
15040 fail:
15041 return NULL;
15042 }
15043
15044
15045 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15046 PyObject *resultobj = 0;
15047 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15048 wxColour *arg2 = 0 ;
15049 unsigned long result;
15050 void *argp1 = 0 ;
15051 int res1 = 0 ;
15052 wxColour temp2 ;
15053 PyObject * obj0 = 0 ;
15054 PyObject * obj1 = 0 ;
15055 char * kwnames[] = {
15056 (char *) "self",(char *) "colour", NULL
15057 };
15058
15059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
15060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15061 if (!SWIG_IsOK(res1)) {
15062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15063 }
15064 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15065 {
15066 arg2 = &temp2;
15067 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15068 }
15069 {
15070 PyThreadState* __tstate = wxPyBeginAllowThreads();
15071 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15072 wxPyEndAllowThreads(__tstate);
15073 if (PyErr_Occurred()) SWIG_fail;
15074 }
15075 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15076 return resultobj;
15077 fail:
15078 return NULL;
15079 }
15080
15081
15082 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15083 PyObject *obj;
15084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15085 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15086 return SWIG_Py_Void();
15087 }
15088
15089 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15090 return SWIG_Python_InitShadowInstance(args);
15091 }
15092
15093 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15094 PyObject *resultobj = 0;
15095 byte arg1 = (byte) 0 ;
15096 byte arg2 = (byte) 0 ;
15097 byte arg3 = (byte) 0 ;
15098 wxImage_RGBValue *result = 0 ;
15099 unsigned char val1 ;
15100 int ecode1 = 0 ;
15101 unsigned char val2 ;
15102 int ecode2 = 0 ;
15103 unsigned char val3 ;
15104 int ecode3 = 0 ;
15105 PyObject * obj0 = 0 ;
15106 PyObject * obj1 = 0 ;
15107 PyObject * obj2 = 0 ;
15108 char * kwnames[] = {
15109 (char *) "r",(char *) "g",(char *) "b", NULL
15110 };
15111
15112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15113 if (obj0) {
15114 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15115 if (!SWIG_IsOK(ecode1)) {
15116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15117 }
15118 arg1 = static_cast< byte >(val1);
15119 }
15120 if (obj1) {
15121 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15122 if (!SWIG_IsOK(ecode2)) {
15123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15124 }
15125 arg2 = static_cast< byte >(val2);
15126 }
15127 if (obj2) {
15128 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15129 if (!SWIG_IsOK(ecode3)) {
15130 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15131 }
15132 arg3 = static_cast< byte >(val3);
15133 }
15134 {
15135 PyThreadState* __tstate = wxPyBeginAllowThreads();
15136 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15137 wxPyEndAllowThreads(__tstate);
15138 if (PyErr_Occurred()) SWIG_fail;
15139 }
15140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15141 return resultobj;
15142 fail:
15143 return NULL;
15144 }
15145
15146
15147 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15148 PyObject *resultobj = 0;
15149 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15150 byte arg2 ;
15151 void *argp1 = 0 ;
15152 int res1 = 0 ;
15153 unsigned char val2 ;
15154 int ecode2 = 0 ;
15155 PyObject *swig_obj[2] ;
15156
15157 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15159 if (!SWIG_IsOK(res1)) {
15160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15161 }
15162 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15163 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15164 if (!SWIG_IsOK(ecode2)) {
15165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15166 }
15167 arg2 = static_cast< byte >(val2);
15168 if (arg1) (arg1)->red = arg2;
15169
15170 resultobj = SWIG_Py_Void();
15171 return resultobj;
15172 fail:
15173 return NULL;
15174 }
15175
15176
15177 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15178 PyObject *resultobj = 0;
15179 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15180 byte result;
15181 void *argp1 = 0 ;
15182 int res1 = 0 ;
15183 PyObject *swig_obj[1] ;
15184
15185 if (!args) SWIG_fail;
15186 swig_obj[0] = args;
15187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15188 if (!SWIG_IsOK(res1)) {
15189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15190 }
15191 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15192 result = (byte) ((arg1)->red);
15193 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15194 return resultobj;
15195 fail:
15196 return NULL;
15197 }
15198
15199
15200 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15201 PyObject *resultobj = 0;
15202 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15203 byte arg2 ;
15204 void *argp1 = 0 ;
15205 int res1 = 0 ;
15206 unsigned char val2 ;
15207 int ecode2 = 0 ;
15208 PyObject *swig_obj[2] ;
15209
15210 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15212 if (!SWIG_IsOK(res1)) {
15213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15214 }
15215 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15216 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15217 if (!SWIG_IsOK(ecode2)) {
15218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15219 }
15220 arg2 = static_cast< byte >(val2);
15221 if (arg1) (arg1)->green = arg2;
15222
15223 resultobj = SWIG_Py_Void();
15224 return resultobj;
15225 fail:
15226 return NULL;
15227 }
15228
15229
15230 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15231 PyObject *resultobj = 0;
15232 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15233 byte result;
15234 void *argp1 = 0 ;
15235 int res1 = 0 ;
15236 PyObject *swig_obj[1] ;
15237
15238 if (!args) SWIG_fail;
15239 swig_obj[0] = args;
15240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15241 if (!SWIG_IsOK(res1)) {
15242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15243 }
15244 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15245 result = (byte) ((arg1)->green);
15246 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15247 return resultobj;
15248 fail:
15249 return NULL;
15250 }
15251
15252
15253 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15254 PyObject *resultobj = 0;
15255 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15256 byte arg2 ;
15257 void *argp1 = 0 ;
15258 int res1 = 0 ;
15259 unsigned char val2 ;
15260 int ecode2 = 0 ;
15261 PyObject *swig_obj[2] ;
15262
15263 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15265 if (!SWIG_IsOK(res1)) {
15266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15267 }
15268 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15269 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15270 if (!SWIG_IsOK(ecode2)) {
15271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15272 }
15273 arg2 = static_cast< byte >(val2);
15274 if (arg1) (arg1)->blue = arg2;
15275
15276 resultobj = SWIG_Py_Void();
15277 return resultobj;
15278 fail:
15279 return NULL;
15280 }
15281
15282
15283 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15284 PyObject *resultobj = 0;
15285 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15286 byte result;
15287 void *argp1 = 0 ;
15288 int res1 = 0 ;
15289 PyObject *swig_obj[1] ;
15290
15291 if (!args) SWIG_fail;
15292 swig_obj[0] = args;
15293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15294 if (!SWIG_IsOK(res1)) {
15295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15296 }
15297 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15298 result = (byte) ((arg1)->blue);
15299 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15300 return resultobj;
15301 fail:
15302 return NULL;
15303 }
15304
15305
15306 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15307 PyObject *obj;
15308 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15309 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15310 return SWIG_Py_Void();
15311 }
15312
15313 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15314 return SWIG_Python_InitShadowInstance(args);
15315 }
15316
15317 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15318 PyObject *resultobj = 0;
15319 double arg1 = (double) 0.0 ;
15320 double arg2 = (double) 0.0 ;
15321 double arg3 = (double) 0.0 ;
15322 wxImage_HSVValue *result = 0 ;
15323 double val1 ;
15324 int ecode1 = 0 ;
15325 double val2 ;
15326 int ecode2 = 0 ;
15327 double val3 ;
15328 int ecode3 = 0 ;
15329 PyObject * obj0 = 0 ;
15330 PyObject * obj1 = 0 ;
15331 PyObject * obj2 = 0 ;
15332 char * kwnames[] = {
15333 (char *) "h",(char *) "s",(char *) "v", NULL
15334 };
15335
15336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15337 if (obj0) {
15338 ecode1 = SWIG_AsVal_double(obj0, &val1);
15339 if (!SWIG_IsOK(ecode1)) {
15340 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15341 }
15342 arg1 = static_cast< double >(val1);
15343 }
15344 if (obj1) {
15345 ecode2 = SWIG_AsVal_double(obj1, &val2);
15346 if (!SWIG_IsOK(ecode2)) {
15347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15348 }
15349 arg2 = static_cast< double >(val2);
15350 }
15351 if (obj2) {
15352 ecode3 = SWIG_AsVal_double(obj2, &val3);
15353 if (!SWIG_IsOK(ecode3)) {
15354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15355 }
15356 arg3 = static_cast< double >(val3);
15357 }
15358 {
15359 PyThreadState* __tstate = wxPyBeginAllowThreads();
15360 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15361 wxPyEndAllowThreads(__tstate);
15362 if (PyErr_Occurred()) SWIG_fail;
15363 }
15364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15365 return resultobj;
15366 fail:
15367 return NULL;
15368 }
15369
15370
15371 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15372 PyObject *resultobj = 0;
15373 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15374 double arg2 ;
15375 void *argp1 = 0 ;
15376 int res1 = 0 ;
15377 double val2 ;
15378 int ecode2 = 0 ;
15379 PyObject *swig_obj[2] ;
15380
15381 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15383 if (!SWIG_IsOK(res1)) {
15384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15385 }
15386 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15387 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15388 if (!SWIG_IsOK(ecode2)) {
15389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15390 }
15391 arg2 = static_cast< double >(val2);
15392 if (arg1) (arg1)->hue = arg2;
15393
15394 resultobj = SWIG_Py_Void();
15395 return resultobj;
15396 fail:
15397 return NULL;
15398 }
15399
15400
15401 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15402 PyObject *resultobj = 0;
15403 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15404 double result;
15405 void *argp1 = 0 ;
15406 int res1 = 0 ;
15407 PyObject *swig_obj[1] ;
15408
15409 if (!args) SWIG_fail;
15410 swig_obj[0] = args;
15411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15412 if (!SWIG_IsOK(res1)) {
15413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15414 }
15415 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15416 result = (double) ((arg1)->hue);
15417 resultobj = SWIG_From_double(static_cast< double >(result));
15418 return resultobj;
15419 fail:
15420 return NULL;
15421 }
15422
15423
15424 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15425 PyObject *resultobj = 0;
15426 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15427 double arg2 ;
15428 void *argp1 = 0 ;
15429 int res1 = 0 ;
15430 double val2 ;
15431 int ecode2 = 0 ;
15432 PyObject *swig_obj[2] ;
15433
15434 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15436 if (!SWIG_IsOK(res1)) {
15437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15438 }
15439 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15440 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15441 if (!SWIG_IsOK(ecode2)) {
15442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15443 }
15444 arg2 = static_cast< double >(val2);
15445 if (arg1) (arg1)->saturation = arg2;
15446
15447 resultobj = SWIG_Py_Void();
15448 return resultobj;
15449 fail:
15450 return NULL;
15451 }
15452
15453
15454 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15455 PyObject *resultobj = 0;
15456 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15457 double result;
15458 void *argp1 = 0 ;
15459 int res1 = 0 ;
15460 PyObject *swig_obj[1] ;
15461
15462 if (!args) SWIG_fail;
15463 swig_obj[0] = args;
15464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15465 if (!SWIG_IsOK(res1)) {
15466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15467 }
15468 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15469 result = (double) ((arg1)->saturation);
15470 resultobj = SWIG_From_double(static_cast< double >(result));
15471 return resultobj;
15472 fail:
15473 return NULL;
15474 }
15475
15476
15477 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15478 PyObject *resultobj = 0;
15479 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15480 double arg2 ;
15481 void *argp1 = 0 ;
15482 int res1 = 0 ;
15483 double val2 ;
15484 int ecode2 = 0 ;
15485 PyObject *swig_obj[2] ;
15486
15487 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15489 if (!SWIG_IsOK(res1)) {
15490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15491 }
15492 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15493 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15494 if (!SWIG_IsOK(ecode2)) {
15495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15496 }
15497 arg2 = static_cast< double >(val2);
15498 if (arg1) (arg1)->value = arg2;
15499
15500 resultobj = SWIG_Py_Void();
15501 return resultobj;
15502 fail:
15503 return NULL;
15504 }
15505
15506
15507 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15508 PyObject *resultobj = 0;
15509 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15510 double result;
15511 void *argp1 = 0 ;
15512 int res1 = 0 ;
15513 PyObject *swig_obj[1] ;
15514
15515 if (!args) SWIG_fail;
15516 swig_obj[0] = args;
15517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15518 if (!SWIG_IsOK(res1)) {
15519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15520 }
15521 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15522 result = (double) ((arg1)->value);
15523 resultobj = SWIG_From_double(static_cast< double >(result));
15524 return resultobj;
15525 fail:
15526 return NULL;
15527 }
15528
15529
15530 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15531 PyObject *obj;
15532 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15533 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15534 return SWIG_Py_Void();
15535 }
15536
15537 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15538 return SWIG_Python_InitShadowInstance(args);
15539 }
15540
15541 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15542 PyObject *resultobj = 0;
15543 wxString *arg1 = 0 ;
15544 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15545 int arg3 = (int) -1 ;
15546 wxImage *result = 0 ;
15547 bool temp1 = false ;
15548 long val2 ;
15549 int ecode2 = 0 ;
15550 int val3 ;
15551 int ecode3 = 0 ;
15552 PyObject * obj0 = 0 ;
15553 PyObject * obj1 = 0 ;
15554 PyObject * obj2 = 0 ;
15555 char * kwnames[] = {
15556 (char *) "name",(char *) "type",(char *) "index", NULL
15557 };
15558
15559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15560 {
15561 arg1 = wxString_in_helper(obj0);
15562 if (arg1 == NULL) SWIG_fail;
15563 temp1 = true;
15564 }
15565 if (obj1) {
15566 ecode2 = SWIG_AsVal_long(obj1, &val2);
15567 if (!SWIG_IsOK(ecode2)) {
15568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15569 }
15570 arg2 = static_cast< long >(val2);
15571 }
15572 if (obj2) {
15573 ecode3 = SWIG_AsVal_int(obj2, &val3);
15574 if (!SWIG_IsOK(ecode3)) {
15575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15576 }
15577 arg3 = static_cast< int >(val3);
15578 }
15579 {
15580 PyThreadState* __tstate = wxPyBeginAllowThreads();
15581 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15582 wxPyEndAllowThreads(__tstate);
15583 if (PyErr_Occurred()) SWIG_fail;
15584 }
15585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15586 {
15587 if (temp1)
15588 delete arg1;
15589 }
15590 return resultobj;
15591 fail:
15592 {
15593 if (temp1)
15594 delete arg1;
15595 }
15596 return NULL;
15597 }
15598
15599
15600 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15601 PyObject *resultobj = 0;
15602 wxImage *arg1 = (wxImage *) 0 ;
15603 void *argp1 = 0 ;
15604 int res1 = 0 ;
15605 PyObject *swig_obj[1] ;
15606
15607 if (!args) SWIG_fail;
15608 swig_obj[0] = args;
15609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15610 if (!SWIG_IsOK(res1)) {
15611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15612 }
15613 arg1 = reinterpret_cast< wxImage * >(argp1);
15614 {
15615 PyThreadState* __tstate = wxPyBeginAllowThreads();
15616 delete arg1;
15617
15618 wxPyEndAllowThreads(__tstate);
15619 if (PyErr_Occurred()) SWIG_fail;
15620 }
15621 resultobj = SWIG_Py_Void();
15622 return resultobj;
15623 fail:
15624 return NULL;
15625 }
15626
15627
15628 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15629 PyObject *resultobj = 0;
15630 wxString *arg1 = 0 ;
15631 wxString *arg2 = 0 ;
15632 int arg3 = (int) -1 ;
15633 wxImage *result = 0 ;
15634 bool temp1 = false ;
15635 bool temp2 = false ;
15636 int val3 ;
15637 int ecode3 = 0 ;
15638 PyObject * obj0 = 0 ;
15639 PyObject * obj1 = 0 ;
15640 PyObject * obj2 = 0 ;
15641 char * kwnames[] = {
15642 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15643 };
15644
15645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15646 {
15647 arg1 = wxString_in_helper(obj0);
15648 if (arg1 == NULL) SWIG_fail;
15649 temp1 = true;
15650 }
15651 {
15652 arg2 = wxString_in_helper(obj1);
15653 if (arg2 == NULL) SWIG_fail;
15654 temp2 = true;
15655 }
15656 if (obj2) {
15657 ecode3 = SWIG_AsVal_int(obj2, &val3);
15658 if (!SWIG_IsOK(ecode3)) {
15659 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15660 }
15661 arg3 = static_cast< int >(val3);
15662 }
15663 {
15664 PyThreadState* __tstate = wxPyBeginAllowThreads();
15665 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15666 wxPyEndAllowThreads(__tstate);
15667 if (PyErr_Occurred()) SWIG_fail;
15668 }
15669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15670 {
15671 if (temp1)
15672 delete arg1;
15673 }
15674 {
15675 if (temp2)
15676 delete arg2;
15677 }
15678 return resultobj;
15679 fail:
15680 {
15681 if (temp1)
15682 delete arg1;
15683 }
15684 {
15685 if (temp2)
15686 delete arg2;
15687 }
15688 return NULL;
15689 }
15690
15691
15692 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15693 PyObject *resultobj = 0;
15694 wxInputStream *arg1 = 0 ;
15695 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15696 int arg3 = (int) -1 ;
15697 wxImage *result = 0 ;
15698 wxPyInputStream *temp1 ;
15699 bool created1 ;
15700 long val2 ;
15701 int ecode2 = 0 ;
15702 int val3 ;
15703 int ecode3 = 0 ;
15704 PyObject * obj0 = 0 ;
15705 PyObject * obj1 = 0 ;
15706 PyObject * obj2 = 0 ;
15707 char * kwnames[] = {
15708 (char *) "stream",(char *) "type",(char *) "index", NULL
15709 };
15710
15711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15712 {
15713 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15714 arg1 = temp1->m_wxis;
15715 created1 = false;
15716 } else {
15717 PyErr_Clear(); // clear the failure of the wxPyConvert above
15718 arg1 = wxPyCBInputStream_create(obj0, false);
15719 if (arg1 == NULL) {
15720 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15721 SWIG_fail;
15722 }
15723 created1 = true;
15724 }
15725 }
15726 if (obj1) {
15727 ecode2 = SWIG_AsVal_long(obj1, &val2);
15728 if (!SWIG_IsOK(ecode2)) {
15729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15730 }
15731 arg2 = static_cast< long >(val2);
15732 }
15733 if (obj2) {
15734 ecode3 = SWIG_AsVal_int(obj2, &val3);
15735 if (!SWIG_IsOK(ecode3)) {
15736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15737 }
15738 arg3 = static_cast< int >(val3);
15739 }
15740 {
15741 PyThreadState* __tstate = wxPyBeginAllowThreads();
15742 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15743 wxPyEndAllowThreads(__tstate);
15744 if (PyErr_Occurred()) SWIG_fail;
15745 }
15746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15747 {
15748 if (created1) delete arg1;
15749 }
15750 return resultobj;
15751 fail:
15752 {
15753 if (created1) delete arg1;
15754 }
15755 return NULL;
15756 }
15757
15758
15759 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15760 PyObject *resultobj = 0;
15761 wxInputStream *arg1 = 0 ;
15762 wxString *arg2 = 0 ;
15763 int arg3 = (int) -1 ;
15764 wxImage *result = 0 ;
15765 wxPyInputStream *temp1 ;
15766 bool created1 ;
15767 bool temp2 = false ;
15768 int val3 ;
15769 int ecode3 = 0 ;
15770 PyObject * obj0 = 0 ;
15771 PyObject * obj1 = 0 ;
15772 PyObject * obj2 = 0 ;
15773 char * kwnames[] = {
15774 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15775 };
15776
15777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15778 {
15779 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15780 arg1 = temp1->m_wxis;
15781 created1 = false;
15782 } else {
15783 PyErr_Clear(); // clear the failure of the wxPyConvert above
15784 arg1 = wxPyCBInputStream_create(obj0, false);
15785 if (arg1 == NULL) {
15786 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15787 SWIG_fail;
15788 }
15789 created1 = true;
15790 }
15791 }
15792 {
15793 arg2 = wxString_in_helper(obj1);
15794 if (arg2 == NULL) SWIG_fail;
15795 temp2 = true;
15796 }
15797 if (obj2) {
15798 ecode3 = SWIG_AsVal_int(obj2, &val3);
15799 if (!SWIG_IsOK(ecode3)) {
15800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15801 }
15802 arg3 = static_cast< int >(val3);
15803 }
15804 {
15805 PyThreadState* __tstate = wxPyBeginAllowThreads();
15806 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15807 wxPyEndAllowThreads(__tstate);
15808 if (PyErr_Occurred()) SWIG_fail;
15809 }
15810 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15811 {
15812 if (created1) delete arg1;
15813 }
15814 {
15815 if (temp2)
15816 delete arg2;
15817 }
15818 return resultobj;
15819 fail:
15820 {
15821 if (created1) delete arg1;
15822 }
15823 {
15824 if (temp2)
15825 delete arg2;
15826 }
15827 return NULL;
15828 }
15829
15830
15831 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15832 PyObject *resultobj = 0;
15833 int arg1 = (int) 0 ;
15834 int arg2 = (int) 0 ;
15835 bool arg3 = (bool) true ;
15836 wxImage *result = 0 ;
15837 int val1 ;
15838 int ecode1 = 0 ;
15839 int val2 ;
15840 int ecode2 = 0 ;
15841 bool val3 ;
15842 int ecode3 = 0 ;
15843 PyObject * obj0 = 0 ;
15844 PyObject * obj1 = 0 ;
15845 PyObject * obj2 = 0 ;
15846 char * kwnames[] = {
15847 (char *) "width",(char *) "height",(char *) "clear", NULL
15848 };
15849
15850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15851 if (obj0) {
15852 ecode1 = SWIG_AsVal_int(obj0, &val1);
15853 if (!SWIG_IsOK(ecode1)) {
15854 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15855 }
15856 arg1 = static_cast< int >(val1);
15857 }
15858 if (obj1) {
15859 ecode2 = SWIG_AsVal_int(obj1, &val2);
15860 if (!SWIG_IsOK(ecode2)) {
15861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15862 }
15863 arg2 = static_cast< int >(val2);
15864 }
15865 if (obj2) {
15866 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15867 if (!SWIG_IsOK(ecode3)) {
15868 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15869 }
15870 arg3 = static_cast< bool >(val3);
15871 }
15872 {
15873 PyThreadState* __tstate = wxPyBeginAllowThreads();
15874 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15875 wxPyEndAllowThreads(__tstate);
15876 if (PyErr_Occurred()) SWIG_fail;
15877 }
15878 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15879 return resultobj;
15880 fail:
15881 return NULL;
15882 }
15883
15884
15885 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15886 PyObject *resultobj = 0;
15887 wxBitmap *arg1 = 0 ;
15888 wxImage *result = 0 ;
15889 void *argp1 = 0 ;
15890 int res1 = 0 ;
15891 PyObject * obj0 = 0 ;
15892 char * kwnames[] = {
15893 (char *) "bitmap", NULL
15894 };
15895
15896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15897 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15898 if (!SWIG_IsOK(res1)) {
15899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15900 }
15901 if (!argp1) {
15902 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15903 }
15904 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15905 {
15906 if (!wxPyCheckForApp()) SWIG_fail;
15907 PyThreadState* __tstate = wxPyBeginAllowThreads();
15908 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15909 wxPyEndAllowThreads(__tstate);
15910 if (PyErr_Occurred()) SWIG_fail;
15911 }
15912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15913 return resultobj;
15914 fail:
15915 return NULL;
15916 }
15917
15918
15919 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15920 PyObject *resultobj = 0;
15921 int arg1 ;
15922 int arg2 ;
15923 buffer arg3 ;
15924 int arg4 ;
15925 wxImage *result = 0 ;
15926 int val1 ;
15927 int ecode1 = 0 ;
15928 int val2 ;
15929 int ecode2 = 0 ;
15930 Py_ssize_t temp3 ;
15931 PyObject * obj0 = 0 ;
15932 PyObject * obj1 = 0 ;
15933 PyObject * obj2 = 0 ;
15934 char * kwnames[] = {
15935 (char *) "width",(char *) "height",(char *) "data", NULL
15936 };
15937
15938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15939 ecode1 = SWIG_AsVal_int(obj0, &val1);
15940 if (!SWIG_IsOK(ecode1)) {
15941 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15942 }
15943 arg1 = static_cast< int >(val1);
15944 ecode2 = SWIG_AsVal_int(obj1, &val2);
15945 if (!SWIG_IsOK(ecode2)) {
15946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15947 }
15948 arg2 = static_cast< int >(val2);
15949 {
15950 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15951 arg4 = (int)temp3;
15952 }
15953 {
15954 PyThreadState* __tstate = wxPyBeginAllowThreads();
15955 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
15956 wxPyEndAllowThreads(__tstate);
15957 if (PyErr_Occurred()) SWIG_fail;
15958 }
15959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15960 return resultobj;
15961 fail:
15962 return NULL;
15963 }
15964
15965
15966 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15967 PyObject *resultobj = 0;
15968 int arg1 ;
15969 int arg2 ;
15970 buffer arg3 ;
15971 int arg4 ;
15972 buffer arg5 ;
15973 int arg6 ;
15974 wxImage *result = 0 ;
15975 int val1 ;
15976 int ecode1 = 0 ;
15977 int val2 ;
15978 int ecode2 = 0 ;
15979 Py_ssize_t temp3 ;
15980 Py_ssize_t temp5 ;
15981 PyObject * obj0 = 0 ;
15982 PyObject * obj1 = 0 ;
15983 PyObject * obj2 = 0 ;
15984 PyObject * obj3 = 0 ;
15985 char * kwnames[] = {
15986 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
15987 };
15988
15989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15990 ecode1 = SWIG_AsVal_int(obj0, &val1);
15991 if (!SWIG_IsOK(ecode1)) {
15992 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
15993 }
15994 arg1 = static_cast< int >(val1);
15995 ecode2 = SWIG_AsVal_int(obj1, &val2);
15996 if (!SWIG_IsOK(ecode2)) {
15997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
15998 }
15999 arg2 = static_cast< int >(val2);
16000 {
16001 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
16002 arg4 = (int)temp3;
16003 }
16004 {
16005 if (obj3 != Py_None) {
16006 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
16007 arg6 = (int)temp5;
16008 }
16009 }
16010 {
16011 PyThreadState* __tstate = wxPyBeginAllowThreads();
16012 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
16013 wxPyEndAllowThreads(__tstate);
16014 if (PyErr_Occurred()) SWIG_fail;
16015 }
16016 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16017 return resultobj;
16018 fail:
16019 return NULL;
16020 }
16021
16022
16023 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16024 PyObject *resultobj = 0;
16025 wxImage *arg1 = (wxImage *) 0 ;
16026 int arg2 ;
16027 int arg3 ;
16028 bool arg4 = (bool) true ;
16029 void *argp1 = 0 ;
16030 int res1 = 0 ;
16031 int val2 ;
16032 int ecode2 = 0 ;
16033 int val3 ;
16034 int ecode3 = 0 ;
16035 bool val4 ;
16036 int ecode4 = 0 ;
16037 PyObject * obj0 = 0 ;
16038 PyObject * obj1 = 0 ;
16039 PyObject * obj2 = 0 ;
16040 PyObject * obj3 = 0 ;
16041 char * kwnames[] = {
16042 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
16043 };
16044
16045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16047 if (!SWIG_IsOK(res1)) {
16048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
16049 }
16050 arg1 = reinterpret_cast< wxImage * >(argp1);
16051 ecode2 = SWIG_AsVal_int(obj1, &val2);
16052 if (!SWIG_IsOK(ecode2)) {
16053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
16054 }
16055 arg2 = static_cast< int >(val2);
16056 ecode3 = SWIG_AsVal_int(obj2, &val3);
16057 if (!SWIG_IsOK(ecode3)) {
16058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
16059 }
16060 arg3 = static_cast< int >(val3);
16061 if (obj3) {
16062 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16063 if (!SWIG_IsOK(ecode4)) {
16064 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
16065 }
16066 arg4 = static_cast< bool >(val4);
16067 }
16068 {
16069 PyThreadState* __tstate = wxPyBeginAllowThreads();
16070 (arg1)->Create(arg2,arg3,arg4);
16071 wxPyEndAllowThreads(__tstate);
16072 if (PyErr_Occurred()) SWIG_fail;
16073 }
16074 resultobj = SWIG_Py_Void();
16075 return resultobj;
16076 fail:
16077 return NULL;
16078 }
16079
16080
16081 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16082 PyObject *resultobj = 0;
16083 wxImage *arg1 = (wxImage *) 0 ;
16084 void *argp1 = 0 ;
16085 int res1 = 0 ;
16086 PyObject *swig_obj[1] ;
16087
16088 if (!args) SWIG_fail;
16089 swig_obj[0] = args;
16090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16091 if (!SWIG_IsOK(res1)) {
16092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16093 }
16094 arg1 = reinterpret_cast< wxImage * >(argp1);
16095 {
16096 PyThreadState* __tstate = wxPyBeginAllowThreads();
16097 (arg1)->Destroy();
16098 wxPyEndAllowThreads(__tstate);
16099 if (PyErr_Occurred()) SWIG_fail;
16100 }
16101 resultobj = SWIG_Py_Void();
16102 return resultobj;
16103 fail:
16104 return NULL;
16105 }
16106
16107
16108 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16109 PyObject *resultobj = 0;
16110 wxImage *arg1 = (wxImage *) 0 ;
16111 int arg2 ;
16112 int arg3 ;
16113 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16114 SwigValueWrapper<wxImage > result;
16115 void *argp1 = 0 ;
16116 int res1 = 0 ;
16117 int val2 ;
16118 int ecode2 = 0 ;
16119 int val3 ;
16120 int ecode3 = 0 ;
16121 int val4 ;
16122 int ecode4 = 0 ;
16123 PyObject * obj0 = 0 ;
16124 PyObject * obj1 = 0 ;
16125 PyObject * obj2 = 0 ;
16126 PyObject * obj3 = 0 ;
16127 char * kwnames[] = {
16128 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16129 };
16130
16131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
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_Scale" "', 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_Scale" "', expected argument " "3"" of type '" "int""'");
16145 }
16146 arg3 = static_cast< int >(val3);
16147 if (obj3) {
16148 ecode4 = SWIG_AsVal_int(obj3, &val4);
16149 if (!SWIG_IsOK(ecode4)) {
16150 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16151 }
16152 arg4 = static_cast< int >(val4);
16153 }
16154 {
16155 PyThreadState* __tstate = wxPyBeginAllowThreads();
16156 result = (arg1)->Scale(arg2,arg3,arg4);
16157 wxPyEndAllowThreads(__tstate);
16158 if (PyErr_Occurred()) SWIG_fail;
16159 }
16160 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16161 return resultobj;
16162 fail:
16163 return NULL;
16164 }
16165
16166
16167 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16168 PyObject *resultobj = 0;
16169 wxImage *arg1 = (wxImage *) 0 ;
16170 int arg2 ;
16171 int arg3 ;
16172 SwigValueWrapper<wxImage > result;
16173 void *argp1 = 0 ;
16174 int res1 = 0 ;
16175 int val2 ;
16176 int ecode2 = 0 ;
16177 int val3 ;
16178 int ecode3 = 0 ;
16179 PyObject * obj0 = 0 ;
16180 PyObject * obj1 = 0 ;
16181 PyObject * obj2 = 0 ;
16182 char * kwnames[] = {
16183 (char *) "self",(char *) "width",(char *) "height", NULL
16184 };
16185
16186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16188 if (!SWIG_IsOK(res1)) {
16189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16190 }
16191 arg1 = reinterpret_cast< wxImage * >(argp1);
16192 ecode2 = SWIG_AsVal_int(obj1, &val2);
16193 if (!SWIG_IsOK(ecode2)) {
16194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16195 }
16196 arg2 = static_cast< int >(val2);
16197 ecode3 = SWIG_AsVal_int(obj2, &val3);
16198 if (!SWIG_IsOK(ecode3)) {
16199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16200 }
16201 arg3 = static_cast< int >(val3);
16202 {
16203 PyThreadState* __tstate = wxPyBeginAllowThreads();
16204 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16205 wxPyEndAllowThreads(__tstate);
16206 if (PyErr_Occurred()) SWIG_fail;
16207 }
16208 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16209 return resultobj;
16210 fail:
16211 return NULL;
16212 }
16213
16214
16215 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16216 PyObject *resultobj = 0;
16217 wxImage *arg1 = (wxImage *) 0 ;
16218 int arg2 ;
16219 int arg3 ;
16220 SwigValueWrapper<wxImage > result;
16221 void *argp1 = 0 ;
16222 int res1 = 0 ;
16223 int val2 ;
16224 int ecode2 = 0 ;
16225 int val3 ;
16226 int ecode3 = 0 ;
16227 PyObject * obj0 = 0 ;
16228 PyObject * obj1 = 0 ;
16229 PyObject * obj2 = 0 ;
16230 char * kwnames[] = {
16231 (char *) "self",(char *) "width",(char *) "height", NULL
16232 };
16233
16234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16236 if (!SWIG_IsOK(res1)) {
16237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16238 }
16239 arg1 = reinterpret_cast< wxImage * >(argp1);
16240 ecode2 = SWIG_AsVal_int(obj1, &val2);
16241 if (!SWIG_IsOK(ecode2)) {
16242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16243 }
16244 arg2 = static_cast< int >(val2);
16245 ecode3 = SWIG_AsVal_int(obj2, &val3);
16246 if (!SWIG_IsOK(ecode3)) {
16247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16248 }
16249 arg3 = static_cast< int >(val3);
16250 {
16251 PyThreadState* __tstate = wxPyBeginAllowThreads();
16252 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16253 wxPyEndAllowThreads(__tstate);
16254 if (PyErr_Occurred()) SWIG_fail;
16255 }
16256 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16257 return resultobj;
16258 fail:
16259 return NULL;
16260 }
16261
16262
16263 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16264 PyObject *resultobj = 0;
16265 wxImage *arg1 = (wxImage *) 0 ;
16266 int arg2 ;
16267 SwigValueWrapper<wxImage > result;
16268 void *argp1 = 0 ;
16269 int res1 = 0 ;
16270 int val2 ;
16271 int ecode2 = 0 ;
16272 PyObject * obj0 = 0 ;
16273 PyObject * obj1 = 0 ;
16274 char * kwnames[] = {
16275 (char *) "self",(char *) "radius", NULL
16276 };
16277
16278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16280 if (!SWIG_IsOK(res1)) {
16281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16282 }
16283 arg1 = reinterpret_cast< wxImage * >(argp1);
16284 ecode2 = SWIG_AsVal_int(obj1, &val2);
16285 if (!SWIG_IsOK(ecode2)) {
16286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16287 }
16288 arg2 = static_cast< int >(val2);
16289 {
16290 PyThreadState* __tstate = wxPyBeginAllowThreads();
16291 result = (arg1)->Blur(arg2);
16292 wxPyEndAllowThreads(__tstate);
16293 if (PyErr_Occurred()) SWIG_fail;
16294 }
16295 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16296 return resultobj;
16297 fail:
16298 return NULL;
16299 }
16300
16301
16302 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16303 PyObject *resultobj = 0;
16304 wxImage *arg1 = (wxImage *) 0 ;
16305 int arg2 ;
16306 SwigValueWrapper<wxImage > result;
16307 void *argp1 = 0 ;
16308 int res1 = 0 ;
16309 int val2 ;
16310 int ecode2 = 0 ;
16311 PyObject * obj0 = 0 ;
16312 PyObject * obj1 = 0 ;
16313 char * kwnames[] = {
16314 (char *) "self",(char *) "radius", NULL
16315 };
16316
16317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16319 if (!SWIG_IsOK(res1)) {
16320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16321 }
16322 arg1 = reinterpret_cast< wxImage * >(argp1);
16323 ecode2 = SWIG_AsVal_int(obj1, &val2);
16324 if (!SWIG_IsOK(ecode2)) {
16325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16326 }
16327 arg2 = static_cast< int >(val2);
16328 {
16329 PyThreadState* __tstate = wxPyBeginAllowThreads();
16330 result = (arg1)->BlurHorizontal(arg2);
16331 wxPyEndAllowThreads(__tstate);
16332 if (PyErr_Occurred()) SWIG_fail;
16333 }
16334 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16335 return resultobj;
16336 fail:
16337 return NULL;
16338 }
16339
16340
16341 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16342 PyObject *resultobj = 0;
16343 wxImage *arg1 = (wxImage *) 0 ;
16344 int arg2 ;
16345 SwigValueWrapper<wxImage > result;
16346 void *argp1 = 0 ;
16347 int res1 = 0 ;
16348 int val2 ;
16349 int ecode2 = 0 ;
16350 PyObject * obj0 = 0 ;
16351 PyObject * obj1 = 0 ;
16352 char * kwnames[] = {
16353 (char *) "self",(char *) "radius", NULL
16354 };
16355
16356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16358 if (!SWIG_IsOK(res1)) {
16359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16360 }
16361 arg1 = reinterpret_cast< wxImage * >(argp1);
16362 ecode2 = SWIG_AsVal_int(obj1, &val2);
16363 if (!SWIG_IsOK(ecode2)) {
16364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16365 }
16366 arg2 = static_cast< int >(val2);
16367 {
16368 PyThreadState* __tstate = wxPyBeginAllowThreads();
16369 result = (arg1)->BlurVertical(arg2);
16370 wxPyEndAllowThreads(__tstate);
16371 if (PyErr_Occurred()) SWIG_fail;
16372 }
16373 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16374 return resultobj;
16375 fail:
16376 return NULL;
16377 }
16378
16379
16380 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16381 PyObject *resultobj = 0;
16382 wxImage *arg1 = (wxImage *) 0 ;
16383 int arg2 ;
16384 int arg3 ;
16385 SwigValueWrapper<wxImage > result;
16386 void *argp1 = 0 ;
16387 int res1 = 0 ;
16388 int val2 ;
16389 int ecode2 = 0 ;
16390 int val3 ;
16391 int ecode3 = 0 ;
16392 PyObject * obj0 = 0 ;
16393 PyObject * obj1 = 0 ;
16394 PyObject * obj2 = 0 ;
16395 char * kwnames[] = {
16396 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16397 };
16398
16399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16401 if (!SWIG_IsOK(res1)) {
16402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16403 }
16404 arg1 = reinterpret_cast< wxImage * >(argp1);
16405 ecode2 = SWIG_AsVal_int(obj1, &val2);
16406 if (!SWIG_IsOK(ecode2)) {
16407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16408 }
16409 arg2 = static_cast< int >(val2);
16410 ecode3 = SWIG_AsVal_int(obj2, &val3);
16411 if (!SWIG_IsOK(ecode3)) {
16412 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16413 }
16414 arg3 = static_cast< int >(val3);
16415 {
16416 PyThreadState* __tstate = wxPyBeginAllowThreads();
16417 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16418 wxPyEndAllowThreads(__tstate);
16419 if (PyErr_Occurred()) SWIG_fail;
16420 }
16421 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16422 return resultobj;
16423 fail:
16424 return NULL;
16425 }
16426
16427
16428 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16429 PyObject *resultobj = 0;
16430 wxImage *arg1 = (wxImage *) 0 ;
16431 int arg2 ;
16432 int arg3 ;
16433 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16434 wxImage *result = 0 ;
16435 void *argp1 = 0 ;
16436 int res1 = 0 ;
16437 int val2 ;
16438 int ecode2 = 0 ;
16439 int val3 ;
16440 int ecode3 = 0 ;
16441 int val4 ;
16442 int ecode4 = 0 ;
16443 PyObject * obj0 = 0 ;
16444 PyObject * obj1 = 0 ;
16445 PyObject * obj2 = 0 ;
16446 PyObject * obj3 = 0 ;
16447 char * kwnames[] = {
16448 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16449 };
16450
16451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16453 if (!SWIG_IsOK(res1)) {
16454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16455 }
16456 arg1 = reinterpret_cast< wxImage * >(argp1);
16457 ecode2 = SWIG_AsVal_int(obj1, &val2);
16458 if (!SWIG_IsOK(ecode2)) {
16459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16460 }
16461 arg2 = static_cast< int >(val2);
16462 ecode3 = SWIG_AsVal_int(obj2, &val3);
16463 if (!SWIG_IsOK(ecode3)) {
16464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16465 }
16466 arg3 = static_cast< int >(val3);
16467 if (obj3) {
16468 ecode4 = SWIG_AsVal_int(obj3, &val4);
16469 if (!SWIG_IsOK(ecode4)) {
16470 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16471 }
16472 arg4 = static_cast< int >(val4);
16473 }
16474 {
16475 PyThreadState* __tstate = wxPyBeginAllowThreads();
16476 {
16477 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
16478 result = (wxImage *) &_result_ref;
16479 }
16480 wxPyEndAllowThreads(__tstate);
16481 if (PyErr_Occurred()) SWIG_fail;
16482 }
16483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16484 return resultobj;
16485 fail:
16486 return NULL;
16487 }
16488
16489
16490 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16491 PyObject *resultobj = 0;
16492 wxImage *arg1 = (wxImage *) 0 ;
16493 wxSize *arg2 = 0 ;
16494 wxPoint *arg3 = 0 ;
16495 int arg4 = (int) -1 ;
16496 int arg5 = (int) -1 ;
16497 int arg6 = (int) -1 ;
16498 wxImage *result = 0 ;
16499 void *argp1 = 0 ;
16500 int res1 = 0 ;
16501 wxSize temp2 ;
16502 wxPoint temp3 ;
16503 int val4 ;
16504 int ecode4 = 0 ;
16505 int val5 ;
16506 int ecode5 = 0 ;
16507 int val6 ;
16508 int ecode6 = 0 ;
16509 PyObject * obj0 = 0 ;
16510 PyObject * obj1 = 0 ;
16511 PyObject * obj2 = 0 ;
16512 PyObject * obj3 = 0 ;
16513 PyObject * obj4 = 0 ;
16514 PyObject * obj5 = 0 ;
16515 char * kwnames[] = {
16516 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16517 };
16518
16519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16521 if (!SWIG_IsOK(res1)) {
16522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16523 }
16524 arg1 = reinterpret_cast< wxImage * >(argp1);
16525 {
16526 arg2 = &temp2;
16527 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16528 }
16529 {
16530 arg3 = &temp3;
16531 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16532 }
16533 if (obj3) {
16534 ecode4 = SWIG_AsVal_int(obj3, &val4);
16535 if (!SWIG_IsOK(ecode4)) {
16536 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16537 }
16538 arg4 = static_cast< int >(val4);
16539 }
16540 if (obj4) {
16541 ecode5 = SWIG_AsVal_int(obj4, &val5);
16542 if (!SWIG_IsOK(ecode5)) {
16543 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16544 }
16545 arg5 = static_cast< int >(val5);
16546 }
16547 if (obj5) {
16548 ecode6 = SWIG_AsVal_int(obj5, &val6);
16549 if (!SWIG_IsOK(ecode6)) {
16550 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16551 }
16552 arg6 = static_cast< int >(val6);
16553 }
16554 {
16555 PyThreadState* __tstate = wxPyBeginAllowThreads();
16556 {
16557 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16558 result = (wxImage *) &_result_ref;
16559 }
16560 wxPyEndAllowThreads(__tstate);
16561 if (PyErr_Occurred()) SWIG_fail;
16562 }
16563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16564 return resultobj;
16565 fail:
16566 return NULL;
16567 }
16568
16569
16570 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16571 PyObject *resultobj = 0;
16572 wxImage *arg1 = (wxImage *) 0 ;
16573 int arg2 ;
16574 int arg3 ;
16575 byte arg4 ;
16576 byte arg5 ;
16577 byte arg6 ;
16578 void *argp1 = 0 ;
16579 int res1 = 0 ;
16580 int val2 ;
16581 int ecode2 = 0 ;
16582 int val3 ;
16583 int ecode3 = 0 ;
16584 unsigned char val4 ;
16585 int ecode4 = 0 ;
16586 unsigned char val5 ;
16587 int ecode5 = 0 ;
16588 unsigned char val6 ;
16589 int ecode6 = 0 ;
16590 PyObject * obj0 = 0 ;
16591 PyObject * obj1 = 0 ;
16592 PyObject * obj2 = 0 ;
16593 PyObject * obj3 = 0 ;
16594 PyObject * obj4 = 0 ;
16595 PyObject * obj5 = 0 ;
16596 char * kwnames[] = {
16597 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16598 };
16599
16600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16602 if (!SWIG_IsOK(res1)) {
16603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16604 }
16605 arg1 = reinterpret_cast< wxImage * >(argp1);
16606 ecode2 = SWIG_AsVal_int(obj1, &val2);
16607 if (!SWIG_IsOK(ecode2)) {
16608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16609 }
16610 arg2 = static_cast< int >(val2);
16611 ecode3 = SWIG_AsVal_int(obj2, &val3);
16612 if (!SWIG_IsOK(ecode3)) {
16613 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16614 }
16615 arg3 = static_cast< int >(val3);
16616 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16617 if (!SWIG_IsOK(ecode4)) {
16618 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16619 }
16620 arg4 = static_cast< byte >(val4);
16621 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16622 if (!SWIG_IsOK(ecode5)) {
16623 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16624 }
16625 arg5 = static_cast< byte >(val5);
16626 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16627 if (!SWIG_IsOK(ecode6)) {
16628 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16629 }
16630 arg6 = static_cast< byte >(val6);
16631 {
16632 PyThreadState* __tstate = wxPyBeginAllowThreads();
16633 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16634 wxPyEndAllowThreads(__tstate);
16635 if (PyErr_Occurred()) SWIG_fail;
16636 }
16637 resultobj = SWIG_Py_Void();
16638 return resultobj;
16639 fail:
16640 return NULL;
16641 }
16642
16643
16644 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16645 PyObject *resultobj = 0;
16646 wxImage *arg1 = (wxImage *) 0 ;
16647 wxRect *arg2 = 0 ;
16648 byte arg3 ;
16649 byte arg4 ;
16650 byte arg5 ;
16651 void *argp1 = 0 ;
16652 int res1 = 0 ;
16653 wxRect temp2 ;
16654 unsigned char val3 ;
16655 int ecode3 = 0 ;
16656 unsigned char val4 ;
16657 int ecode4 = 0 ;
16658 unsigned char val5 ;
16659 int ecode5 = 0 ;
16660 PyObject * obj0 = 0 ;
16661 PyObject * obj1 = 0 ;
16662 PyObject * obj2 = 0 ;
16663 PyObject * obj3 = 0 ;
16664 PyObject * obj4 = 0 ;
16665 char * kwnames[] = {
16666 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16667 };
16668
16669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16671 if (!SWIG_IsOK(res1)) {
16672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16673 }
16674 arg1 = reinterpret_cast< wxImage * >(argp1);
16675 {
16676 arg2 = &temp2;
16677 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16678 }
16679 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16680 if (!SWIG_IsOK(ecode3)) {
16681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16682 }
16683 arg3 = static_cast< byte >(val3);
16684 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16685 if (!SWIG_IsOK(ecode4)) {
16686 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16687 }
16688 arg4 = static_cast< byte >(val4);
16689 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16690 if (!SWIG_IsOK(ecode5)) {
16691 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16692 }
16693 arg5 = static_cast< byte >(val5);
16694 {
16695 PyThreadState* __tstate = wxPyBeginAllowThreads();
16696 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16697 wxPyEndAllowThreads(__tstate);
16698 if (PyErr_Occurred()) SWIG_fail;
16699 }
16700 resultobj = SWIG_Py_Void();
16701 return resultobj;
16702 fail:
16703 return NULL;
16704 }
16705
16706
16707 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16708 PyObject *resultobj = 0;
16709 wxImage *arg1 = (wxImage *) 0 ;
16710 int arg2 ;
16711 int arg3 ;
16712 byte result;
16713 void *argp1 = 0 ;
16714 int res1 = 0 ;
16715 int val2 ;
16716 int ecode2 = 0 ;
16717 int val3 ;
16718 int ecode3 = 0 ;
16719 PyObject * obj0 = 0 ;
16720 PyObject * obj1 = 0 ;
16721 PyObject * obj2 = 0 ;
16722 char * kwnames[] = {
16723 (char *) "self",(char *) "x",(char *) "y", NULL
16724 };
16725
16726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16728 if (!SWIG_IsOK(res1)) {
16729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
16730 }
16731 arg1 = reinterpret_cast< wxImage * >(argp1);
16732 ecode2 = SWIG_AsVal_int(obj1, &val2);
16733 if (!SWIG_IsOK(ecode2)) {
16734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
16735 }
16736 arg2 = static_cast< int >(val2);
16737 ecode3 = SWIG_AsVal_int(obj2, &val3);
16738 if (!SWIG_IsOK(ecode3)) {
16739 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
16740 }
16741 arg3 = static_cast< int >(val3);
16742 {
16743 PyThreadState* __tstate = wxPyBeginAllowThreads();
16744 result = (byte)(arg1)->GetRed(arg2,arg3);
16745 wxPyEndAllowThreads(__tstate);
16746 if (PyErr_Occurred()) SWIG_fail;
16747 }
16748 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16749 return resultobj;
16750 fail:
16751 return NULL;
16752 }
16753
16754
16755 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16756 PyObject *resultobj = 0;
16757 wxImage *arg1 = (wxImage *) 0 ;
16758 int arg2 ;
16759 int arg3 ;
16760 byte result;
16761 void *argp1 = 0 ;
16762 int res1 = 0 ;
16763 int val2 ;
16764 int ecode2 = 0 ;
16765 int val3 ;
16766 int ecode3 = 0 ;
16767 PyObject * obj0 = 0 ;
16768 PyObject * obj1 = 0 ;
16769 PyObject * obj2 = 0 ;
16770 char * kwnames[] = {
16771 (char *) "self",(char *) "x",(char *) "y", NULL
16772 };
16773
16774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16776 if (!SWIG_IsOK(res1)) {
16777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16778 }
16779 arg1 = reinterpret_cast< wxImage * >(argp1);
16780 ecode2 = SWIG_AsVal_int(obj1, &val2);
16781 if (!SWIG_IsOK(ecode2)) {
16782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
16783 }
16784 arg2 = static_cast< int >(val2);
16785 ecode3 = SWIG_AsVal_int(obj2, &val3);
16786 if (!SWIG_IsOK(ecode3)) {
16787 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
16788 }
16789 arg3 = static_cast< int >(val3);
16790 {
16791 PyThreadState* __tstate = wxPyBeginAllowThreads();
16792 result = (byte)(arg1)->GetGreen(arg2,arg3);
16793 wxPyEndAllowThreads(__tstate);
16794 if (PyErr_Occurred()) SWIG_fail;
16795 }
16796 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16797 return resultobj;
16798 fail:
16799 return NULL;
16800 }
16801
16802
16803 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16804 PyObject *resultobj = 0;
16805 wxImage *arg1 = (wxImage *) 0 ;
16806 int arg2 ;
16807 int arg3 ;
16808 byte result;
16809 void *argp1 = 0 ;
16810 int res1 = 0 ;
16811 int val2 ;
16812 int ecode2 = 0 ;
16813 int val3 ;
16814 int ecode3 = 0 ;
16815 PyObject * obj0 = 0 ;
16816 PyObject * obj1 = 0 ;
16817 PyObject * obj2 = 0 ;
16818 char * kwnames[] = {
16819 (char *) "self",(char *) "x",(char *) "y", NULL
16820 };
16821
16822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16824 if (!SWIG_IsOK(res1)) {
16825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16826 }
16827 arg1 = reinterpret_cast< wxImage * >(argp1);
16828 ecode2 = SWIG_AsVal_int(obj1, &val2);
16829 if (!SWIG_IsOK(ecode2)) {
16830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16831 }
16832 arg2 = static_cast< int >(val2);
16833 ecode3 = SWIG_AsVal_int(obj2, &val3);
16834 if (!SWIG_IsOK(ecode3)) {
16835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16836 }
16837 arg3 = static_cast< int >(val3);
16838 {
16839 PyThreadState* __tstate = wxPyBeginAllowThreads();
16840 result = (byte)(arg1)->GetBlue(arg2,arg3);
16841 wxPyEndAllowThreads(__tstate);
16842 if (PyErr_Occurred()) SWIG_fail;
16843 }
16844 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16845 return resultobj;
16846 fail:
16847 return NULL;
16848 }
16849
16850
16851 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16852 PyObject *resultobj = 0;
16853 wxImage *arg1 = (wxImage *) 0 ;
16854 int arg2 ;
16855 int arg3 ;
16856 byte arg4 ;
16857 void *argp1 = 0 ;
16858 int res1 = 0 ;
16859 int val2 ;
16860 int ecode2 = 0 ;
16861 int val3 ;
16862 int ecode3 = 0 ;
16863 unsigned char val4 ;
16864 int ecode4 = 0 ;
16865 PyObject * obj0 = 0 ;
16866 PyObject * obj1 = 0 ;
16867 PyObject * obj2 = 0 ;
16868 PyObject * obj3 = 0 ;
16869 char * kwnames[] = {
16870 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16871 };
16872
16873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16875 if (!SWIG_IsOK(res1)) {
16876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16877 }
16878 arg1 = reinterpret_cast< wxImage * >(argp1);
16879 ecode2 = SWIG_AsVal_int(obj1, &val2);
16880 if (!SWIG_IsOK(ecode2)) {
16881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16882 }
16883 arg2 = static_cast< int >(val2);
16884 ecode3 = SWIG_AsVal_int(obj2, &val3);
16885 if (!SWIG_IsOK(ecode3)) {
16886 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16887 }
16888 arg3 = static_cast< int >(val3);
16889 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16890 if (!SWIG_IsOK(ecode4)) {
16891 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16892 }
16893 arg4 = static_cast< byte >(val4);
16894 {
16895 PyThreadState* __tstate = wxPyBeginAllowThreads();
16896 (arg1)->SetAlpha(arg2,arg3,arg4);
16897 wxPyEndAllowThreads(__tstate);
16898 if (PyErr_Occurred()) SWIG_fail;
16899 }
16900 resultobj = SWIG_Py_Void();
16901 return resultobj;
16902 fail:
16903 return NULL;
16904 }
16905
16906
16907 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16908 PyObject *resultobj = 0;
16909 wxImage *arg1 = (wxImage *) 0 ;
16910 int arg2 ;
16911 int arg3 ;
16912 byte result;
16913 void *argp1 = 0 ;
16914 int res1 = 0 ;
16915 int val2 ;
16916 int ecode2 = 0 ;
16917 int val3 ;
16918 int ecode3 = 0 ;
16919 PyObject * obj0 = 0 ;
16920 PyObject * obj1 = 0 ;
16921 PyObject * obj2 = 0 ;
16922 char * kwnames[] = {
16923 (char *) "self",(char *) "x",(char *) "y", NULL
16924 };
16925
16926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16928 if (!SWIG_IsOK(res1)) {
16929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16930 }
16931 arg1 = reinterpret_cast< wxImage * >(argp1);
16932 ecode2 = SWIG_AsVal_int(obj1, &val2);
16933 if (!SWIG_IsOK(ecode2)) {
16934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16935 }
16936 arg2 = static_cast< int >(val2);
16937 ecode3 = SWIG_AsVal_int(obj2, &val3);
16938 if (!SWIG_IsOK(ecode3)) {
16939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16940 }
16941 arg3 = static_cast< int >(val3);
16942 {
16943 PyThreadState* __tstate = wxPyBeginAllowThreads();
16944 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16945 wxPyEndAllowThreads(__tstate);
16946 if (PyErr_Occurred()) SWIG_fail;
16947 }
16948 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16949 return resultobj;
16950 fail:
16951 return NULL;
16952 }
16953
16954
16955 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16956 PyObject *resultobj = 0;
16957 wxImage *arg1 = (wxImage *) 0 ;
16958 bool result;
16959 void *argp1 = 0 ;
16960 int res1 = 0 ;
16961 PyObject *swig_obj[1] ;
16962
16963 if (!args) SWIG_fail;
16964 swig_obj[0] = args;
16965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16966 if (!SWIG_IsOK(res1)) {
16967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16968 }
16969 arg1 = reinterpret_cast< wxImage * >(argp1);
16970 {
16971 PyThreadState* __tstate = wxPyBeginAllowThreads();
16972 result = (bool)(arg1)->HasAlpha();
16973 wxPyEndAllowThreads(__tstate);
16974 if (PyErr_Occurred()) SWIG_fail;
16975 }
16976 {
16977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16978 }
16979 return resultobj;
16980 fail:
16981 return NULL;
16982 }
16983
16984
16985 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16986 PyObject *resultobj = 0;
16987 wxImage *arg1 = (wxImage *) 0 ;
16988 void *argp1 = 0 ;
16989 int res1 = 0 ;
16990 PyObject *swig_obj[1] ;
16991
16992 if (!args) SWIG_fail;
16993 swig_obj[0] = args;
16994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16995 if (!SWIG_IsOK(res1)) {
16996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16997 }
16998 arg1 = reinterpret_cast< wxImage * >(argp1);
16999 {
17000 PyThreadState* __tstate = wxPyBeginAllowThreads();
17001 (arg1)->InitAlpha();
17002 wxPyEndAllowThreads(__tstate);
17003 if (PyErr_Occurred()) SWIG_fail;
17004 }
17005 resultobj = SWIG_Py_Void();
17006 return resultobj;
17007 fail:
17008 return NULL;
17009 }
17010
17011
17012 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17013 PyObject *resultobj = 0;
17014 wxImage *arg1 = (wxImage *) 0 ;
17015 int arg2 ;
17016 int arg3 ;
17017 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17018 bool result;
17019 void *argp1 = 0 ;
17020 int res1 = 0 ;
17021 int val2 ;
17022 int ecode2 = 0 ;
17023 int val3 ;
17024 int ecode3 = 0 ;
17025 unsigned char val4 ;
17026 int ecode4 = 0 ;
17027 PyObject * obj0 = 0 ;
17028 PyObject * obj1 = 0 ;
17029 PyObject * obj2 = 0 ;
17030 PyObject * obj3 = 0 ;
17031 char * kwnames[] = {
17032 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
17033 };
17034
17035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17037 if (!SWIG_IsOK(res1)) {
17038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
17039 }
17040 arg1 = reinterpret_cast< wxImage * >(argp1);
17041 ecode2 = SWIG_AsVal_int(obj1, &val2);
17042 if (!SWIG_IsOK(ecode2)) {
17043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
17044 }
17045 arg2 = static_cast< int >(val2);
17046 ecode3 = SWIG_AsVal_int(obj2, &val3);
17047 if (!SWIG_IsOK(ecode3)) {
17048 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
17049 }
17050 arg3 = static_cast< int >(val3);
17051 if (obj3) {
17052 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17053 if (!SWIG_IsOK(ecode4)) {
17054 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
17055 }
17056 arg4 = static_cast< byte >(val4);
17057 }
17058 {
17059 PyThreadState* __tstate = wxPyBeginAllowThreads();
17060 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
17061 wxPyEndAllowThreads(__tstate);
17062 if (PyErr_Occurred()) SWIG_fail;
17063 }
17064 {
17065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17066 }
17067 return resultobj;
17068 fail:
17069 return NULL;
17070 }
17071
17072
17073 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17074 PyObject *resultobj = 0;
17075 wxImage *arg1 = (wxImage *) 0 ;
17076 byte *arg2 = (byte *) 0 ;
17077 byte *arg3 = (byte *) 0 ;
17078 byte *arg4 = (byte *) 0 ;
17079 byte arg5 = (byte) 0 ;
17080 byte arg6 = (byte) 0 ;
17081 byte arg7 = (byte) 0 ;
17082 bool result;
17083 void *argp1 = 0 ;
17084 int res1 = 0 ;
17085 byte temp2 ;
17086 int res2 = SWIG_TMPOBJ ;
17087 byte temp3 ;
17088 int res3 = SWIG_TMPOBJ ;
17089 byte temp4 ;
17090 int res4 = SWIG_TMPOBJ ;
17091 unsigned char val5 ;
17092 int ecode5 = 0 ;
17093 unsigned char val6 ;
17094 int ecode6 = 0 ;
17095 unsigned char val7 ;
17096 int ecode7 = 0 ;
17097 PyObject * obj0 = 0 ;
17098 PyObject * obj1 = 0 ;
17099 PyObject * obj2 = 0 ;
17100 PyObject * obj3 = 0 ;
17101 char * kwnames[] = {
17102 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17103 };
17104
17105 arg2 = &temp2;
17106 arg3 = &temp3;
17107 arg4 = &temp4;
17108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17110 if (!SWIG_IsOK(res1)) {
17111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17112 }
17113 arg1 = reinterpret_cast< wxImage * >(argp1);
17114 if (obj1) {
17115 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17116 if (!SWIG_IsOK(ecode5)) {
17117 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17118 }
17119 arg5 = static_cast< byte >(val5);
17120 }
17121 if (obj2) {
17122 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17123 if (!SWIG_IsOK(ecode6)) {
17124 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17125 }
17126 arg6 = static_cast< byte >(val6);
17127 }
17128 if (obj3) {
17129 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17130 if (!SWIG_IsOK(ecode7)) {
17131 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17132 }
17133 arg7 = static_cast< byte >(val7);
17134 }
17135 {
17136 PyThreadState* __tstate = wxPyBeginAllowThreads();
17137 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17138 wxPyEndAllowThreads(__tstate);
17139 if (PyErr_Occurred()) SWIG_fail;
17140 }
17141 {
17142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17143 }
17144 if (SWIG_IsTmpObj(res2)) {
17145 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17146 } else {
17147 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17148 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17149 }
17150 if (SWIG_IsTmpObj(res3)) {
17151 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17152 } else {
17153 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17154 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17155 }
17156 if (SWIG_IsTmpObj(res4)) {
17157 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17158 } else {
17159 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17160 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17161 }
17162 return resultobj;
17163 fail:
17164 return NULL;
17165 }
17166
17167
17168 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17169 PyObject *resultobj = 0;
17170 wxImage *arg1 = (wxImage *) 0 ;
17171 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17172 bool result;
17173 void *argp1 = 0 ;
17174 int res1 = 0 ;
17175 unsigned char val2 ;
17176 int ecode2 = 0 ;
17177 PyObject * obj0 = 0 ;
17178 PyObject * obj1 = 0 ;
17179 char * kwnames[] = {
17180 (char *) "self",(char *) "threshold", NULL
17181 };
17182
17183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17185 if (!SWIG_IsOK(res1)) {
17186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17187 }
17188 arg1 = reinterpret_cast< wxImage * >(argp1);
17189 if (obj1) {
17190 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17191 if (!SWIG_IsOK(ecode2)) {
17192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17193 }
17194 arg2 = static_cast< byte >(val2);
17195 }
17196 {
17197 PyThreadState* __tstate = wxPyBeginAllowThreads();
17198 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17199 wxPyEndAllowThreads(__tstate);
17200 if (PyErr_Occurred()) SWIG_fail;
17201 }
17202 {
17203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17204 }
17205 return resultobj;
17206 fail:
17207 return NULL;
17208 }
17209
17210
17211 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17212 PyObject *resultobj = 0;
17213 wxImage *arg1 = (wxImage *) 0 ;
17214 byte arg2 ;
17215 byte arg3 ;
17216 byte arg4 ;
17217 bool result;
17218 void *argp1 = 0 ;
17219 int res1 = 0 ;
17220 unsigned char val2 ;
17221 int ecode2 = 0 ;
17222 unsigned char val3 ;
17223 int ecode3 = 0 ;
17224 unsigned char val4 ;
17225 int ecode4 = 0 ;
17226 PyObject * obj0 = 0 ;
17227 PyObject * obj1 = 0 ;
17228 PyObject * obj2 = 0 ;
17229 PyObject * obj3 = 0 ;
17230 char * kwnames[] = {
17231 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17232 };
17233
17234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17236 if (!SWIG_IsOK(res1)) {
17237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17238 }
17239 arg1 = reinterpret_cast< wxImage * >(argp1);
17240 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17241 if (!SWIG_IsOK(ecode2)) {
17242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17243 }
17244 arg2 = static_cast< byte >(val2);
17245 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17246 if (!SWIG_IsOK(ecode3)) {
17247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17248 }
17249 arg3 = static_cast< byte >(val3);
17250 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17251 if (!SWIG_IsOK(ecode4)) {
17252 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17253 }
17254 arg4 = static_cast< byte >(val4);
17255 {
17256 PyThreadState* __tstate = wxPyBeginAllowThreads();
17257 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17258 wxPyEndAllowThreads(__tstate);
17259 if (PyErr_Occurred()) SWIG_fail;
17260 }
17261 {
17262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17263 }
17264 return resultobj;
17265 fail:
17266 return NULL;
17267 }
17268
17269
17270 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17271 PyObject *resultobj = 0;
17272 wxImage *arg1 = (wxImage *) 0 ;
17273 wxImage *arg2 = 0 ;
17274 byte arg3 ;
17275 byte arg4 ;
17276 byte arg5 ;
17277 bool result;
17278 void *argp1 = 0 ;
17279 int res1 = 0 ;
17280 void *argp2 = 0 ;
17281 int res2 = 0 ;
17282 unsigned char val3 ;
17283 int ecode3 = 0 ;
17284 unsigned char val4 ;
17285 int ecode4 = 0 ;
17286 unsigned char val5 ;
17287 int ecode5 = 0 ;
17288 PyObject * obj0 = 0 ;
17289 PyObject * obj1 = 0 ;
17290 PyObject * obj2 = 0 ;
17291 PyObject * obj3 = 0 ;
17292 PyObject * obj4 = 0 ;
17293 char * kwnames[] = {
17294 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17295 };
17296
17297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17299 if (!SWIG_IsOK(res1)) {
17300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17301 }
17302 arg1 = reinterpret_cast< wxImage * >(argp1);
17303 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17304 if (!SWIG_IsOK(res2)) {
17305 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17306 }
17307 if (!argp2) {
17308 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17309 }
17310 arg2 = reinterpret_cast< wxImage * >(argp2);
17311 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17312 if (!SWIG_IsOK(ecode3)) {
17313 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17314 }
17315 arg3 = static_cast< byte >(val3);
17316 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17317 if (!SWIG_IsOK(ecode4)) {
17318 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17319 }
17320 arg4 = static_cast< byte >(val4);
17321 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17322 if (!SWIG_IsOK(ecode5)) {
17323 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17324 }
17325 arg5 = static_cast< byte >(val5);
17326 {
17327 PyThreadState* __tstate = wxPyBeginAllowThreads();
17328 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17329 wxPyEndAllowThreads(__tstate);
17330 if (PyErr_Occurred()) SWIG_fail;
17331 }
17332 {
17333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17334 }
17335 return resultobj;
17336 fail:
17337 return NULL;
17338 }
17339
17340
17341 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17342 PyObject *resultobj = 0;
17343 wxString *arg1 = 0 ;
17344 bool result;
17345 bool temp1 = false ;
17346 PyObject * obj0 = 0 ;
17347 char * kwnames[] = {
17348 (char *) "filename", NULL
17349 };
17350
17351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17352 {
17353 arg1 = wxString_in_helper(obj0);
17354 if (arg1 == NULL) SWIG_fail;
17355 temp1 = true;
17356 }
17357 {
17358 PyThreadState* __tstate = wxPyBeginAllowThreads();
17359 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17360 wxPyEndAllowThreads(__tstate);
17361 if (PyErr_Occurred()) SWIG_fail;
17362 }
17363 {
17364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17365 }
17366 {
17367 if (temp1)
17368 delete arg1;
17369 }
17370 return resultobj;
17371 fail:
17372 {
17373 if (temp1)
17374 delete arg1;
17375 }
17376 return NULL;
17377 }
17378
17379
17380 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17381 PyObject *resultobj = 0;
17382 wxString *arg1 = 0 ;
17383 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17384 int result;
17385 bool temp1 = false ;
17386 long val2 ;
17387 int ecode2 = 0 ;
17388 PyObject * obj0 = 0 ;
17389 PyObject * obj1 = 0 ;
17390 char * kwnames[] = {
17391 (char *) "filename",(char *) "type", NULL
17392 };
17393
17394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17395 {
17396 arg1 = wxString_in_helper(obj0);
17397 if (arg1 == NULL) SWIG_fail;
17398 temp1 = true;
17399 }
17400 if (obj1) {
17401 ecode2 = SWIG_AsVal_long(obj1, &val2);
17402 if (!SWIG_IsOK(ecode2)) {
17403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17404 }
17405 arg2 = static_cast< long >(val2);
17406 }
17407 {
17408 PyThreadState* __tstate = wxPyBeginAllowThreads();
17409 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17410 wxPyEndAllowThreads(__tstate);
17411 if (PyErr_Occurred()) SWIG_fail;
17412 }
17413 resultobj = SWIG_From_int(static_cast< int >(result));
17414 {
17415 if (temp1)
17416 delete arg1;
17417 }
17418 return resultobj;
17419 fail:
17420 {
17421 if (temp1)
17422 delete arg1;
17423 }
17424 return NULL;
17425 }
17426
17427
17428 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17429 PyObject *resultobj = 0;
17430 wxImage *arg1 = (wxImage *) 0 ;
17431 wxString *arg2 = 0 ;
17432 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17433 int arg4 = (int) -1 ;
17434 bool result;
17435 void *argp1 = 0 ;
17436 int res1 = 0 ;
17437 bool temp2 = false ;
17438 long val3 ;
17439 int ecode3 = 0 ;
17440 int val4 ;
17441 int ecode4 = 0 ;
17442 PyObject * obj0 = 0 ;
17443 PyObject * obj1 = 0 ;
17444 PyObject * obj2 = 0 ;
17445 PyObject * obj3 = 0 ;
17446 char * kwnames[] = {
17447 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17448 };
17449
17450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17452 if (!SWIG_IsOK(res1)) {
17453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17454 }
17455 arg1 = reinterpret_cast< wxImage * >(argp1);
17456 {
17457 arg2 = wxString_in_helper(obj1);
17458 if (arg2 == NULL) SWIG_fail;
17459 temp2 = true;
17460 }
17461 if (obj2) {
17462 ecode3 = SWIG_AsVal_long(obj2, &val3);
17463 if (!SWIG_IsOK(ecode3)) {
17464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17465 }
17466 arg3 = static_cast< long >(val3);
17467 }
17468 if (obj3) {
17469 ecode4 = SWIG_AsVal_int(obj3, &val4);
17470 if (!SWIG_IsOK(ecode4)) {
17471 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17472 }
17473 arg4 = static_cast< int >(val4);
17474 }
17475 {
17476 PyThreadState* __tstate = wxPyBeginAllowThreads();
17477 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17478 wxPyEndAllowThreads(__tstate);
17479 if (PyErr_Occurred()) SWIG_fail;
17480 }
17481 {
17482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17483 }
17484 {
17485 if (temp2)
17486 delete arg2;
17487 }
17488 return resultobj;
17489 fail:
17490 {
17491 if (temp2)
17492 delete arg2;
17493 }
17494 return NULL;
17495 }
17496
17497
17498 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17499 PyObject *resultobj = 0;
17500 wxImage *arg1 = (wxImage *) 0 ;
17501 wxString *arg2 = 0 ;
17502 wxString *arg3 = 0 ;
17503 int arg4 = (int) -1 ;
17504 bool result;
17505 void *argp1 = 0 ;
17506 int res1 = 0 ;
17507 bool temp2 = false ;
17508 bool temp3 = false ;
17509 int val4 ;
17510 int ecode4 = 0 ;
17511 PyObject * obj0 = 0 ;
17512 PyObject * obj1 = 0 ;
17513 PyObject * obj2 = 0 ;
17514 PyObject * obj3 = 0 ;
17515 char * kwnames[] = {
17516 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17517 };
17518
17519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17521 if (!SWIG_IsOK(res1)) {
17522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17523 }
17524 arg1 = reinterpret_cast< wxImage * >(argp1);
17525 {
17526 arg2 = wxString_in_helper(obj1);
17527 if (arg2 == NULL) SWIG_fail;
17528 temp2 = true;
17529 }
17530 {
17531 arg3 = wxString_in_helper(obj2);
17532 if (arg3 == NULL) SWIG_fail;
17533 temp3 = true;
17534 }
17535 if (obj3) {
17536 ecode4 = SWIG_AsVal_int(obj3, &val4);
17537 if (!SWIG_IsOK(ecode4)) {
17538 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17539 }
17540 arg4 = static_cast< int >(val4);
17541 }
17542 {
17543 PyThreadState* __tstate = wxPyBeginAllowThreads();
17544 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17545 wxPyEndAllowThreads(__tstate);
17546 if (PyErr_Occurred()) SWIG_fail;
17547 }
17548 {
17549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17550 }
17551 {
17552 if (temp2)
17553 delete arg2;
17554 }
17555 {
17556 if (temp3)
17557 delete arg3;
17558 }
17559 return resultobj;
17560 fail:
17561 {
17562 if (temp2)
17563 delete arg2;
17564 }
17565 {
17566 if (temp3)
17567 delete arg3;
17568 }
17569 return NULL;
17570 }
17571
17572
17573 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17574 PyObject *resultobj = 0;
17575 wxImage *arg1 = (wxImage *) 0 ;
17576 wxString *arg2 = 0 ;
17577 int arg3 ;
17578 bool result;
17579 void *argp1 = 0 ;
17580 int res1 = 0 ;
17581 bool temp2 = false ;
17582 int val3 ;
17583 int ecode3 = 0 ;
17584 PyObject * obj0 = 0 ;
17585 PyObject * obj1 = 0 ;
17586 PyObject * obj2 = 0 ;
17587 char * kwnames[] = {
17588 (char *) "self",(char *) "name",(char *) "type", NULL
17589 };
17590
17591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17593 if (!SWIG_IsOK(res1)) {
17594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17595 }
17596 arg1 = reinterpret_cast< wxImage * >(argp1);
17597 {
17598 arg2 = wxString_in_helper(obj1);
17599 if (arg2 == NULL) SWIG_fail;
17600 temp2 = true;
17601 }
17602 ecode3 = SWIG_AsVal_int(obj2, &val3);
17603 if (!SWIG_IsOK(ecode3)) {
17604 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17605 }
17606 arg3 = static_cast< int >(val3);
17607 {
17608 PyThreadState* __tstate = wxPyBeginAllowThreads();
17609 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17610 wxPyEndAllowThreads(__tstate);
17611 if (PyErr_Occurred()) SWIG_fail;
17612 }
17613 {
17614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17615 }
17616 {
17617 if (temp2)
17618 delete arg2;
17619 }
17620 return resultobj;
17621 fail:
17622 {
17623 if (temp2)
17624 delete arg2;
17625 }
17626 return NULL;
17627 }
17628
17629
17630 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17631 PyObject *resultobj = 0;
17632 wxImage *arg1 = (wxImage *) 0 ;
17633 wxString *arg2 = 0 ;
17634 wxString *arg3 = 0 ;
17635 bool result;
17636 void *argp1 = 0 ;
17637 int res1 = 0 ;
17638 bool temp2 = false ;
17639 bool temp3 = false ;
17640 PyObject * obj0 = 0 ;
17641 PyObject * obj1 = 0 ;
17642 PyObject * obj2 = 0 ;
17643 char * kwnames[] = {
17644 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17645 };
17646
17647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17649 if (!SWIG_IsOK(res1)) {
17650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17651 }
17652 arg1 = reinterpret_cast< wxImage * >(argp1);
17653 {
17654 arg2 = wxString_in_helper(obj1);
17655 if (arg2 == NULL) SWIG_fail;
17656 temp2 = true;
17657 }
17658 {
17659 arg3 = wxString_in_helper(obj2);
17660 if (arg3 == NULL) SWIG_fail;
17661 temp3 = true;
17662 }
17663 {
17664 PyThreadState* __tstate = wxPyBeginAllowThreads();
17665 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17666 wxPyEndAllowThreads(__tstate);
17667 if (PyErr_Occurred()) SWIG_fail;
17668 }
17669 {
17670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17671 }
17672 {
17673 if (temp2)
17674 delete arg2;
17675 }
17676 {
17677 if (temp3)
17678 delete arg3;
17679 }
17680 return resultobj;
17681 fail:
17682 {
17683 if (temp2)
17684 delete arg2;
17685 }
17686 {
17687 if (temp3)
17688 delete arg3;
17689 }
17690 return NULL;
17691 }
17692
17693
17694 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17695 PyObject *resultobj = 0;
17696 wxInputStream *arg1 = 0 ;
17697 bool result;
17698 wxPyInputStream *temp1 ;
17699 bool created1 ;
17700 PyObject * obj0 = 0 ;
17701 char * kwnames[] = {
17702 (char *) "stream", NULL
17703 };
17704
17705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17706 {
17707 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17708 arg1 = temp1->m_wxis;
17709 created1 = false;
17710 } else {
17711 PyErr_Clear(); // clear the failure of the wxPyConvert above
17712 arg1 = wxPyCBInputStream_create(obj0, false);
17713 if (arg1 == NULL) {
17714 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17715 SWIG_fail;
17716 }
17717 created1 = true;
17718 }
17719 }
17720 {
17721 PyThreadState* __tstate = wxPyBeginAllowThreads();
17722 result = (bool)wxImage::CanRead(*arg1);
17723 wxPyEndAllowThreads(__tstate);
17724 if (PyErr_Occurred()) SWIG_fail;
17725 }
17726 {
17727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17728 }
17729 {
17730 if (created1) delete arg1;
17731 }
17732 return resultobj;
17733 fail:
17734 {
17735 if (created1) delete arg1;
17736 }
17737 return NULL;
17738 }
17739
17740
17741 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17742 PyObject *resultobj = 0;
17743 wxImage *arg1 = (wxImage *) 0 ;
17744 wxInputStream *arg2 = 0 ;
17745 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17746 int arg4 = (int) -1 ;
17747 bool result;
17748 void *argp1 = 0 ;
17749 int res1 = 0 ;
17750 wxPyInputStream *temp2 ;
17751 bool created2 ;
17752 long val3 ;
17753 int ecode3 = 0 ;
17754 int val4 ;
17755 int ecode4 = 0 ;
17756 PyObject * obj0 = 0 ;
17757 PyObject * obj1 = 0 ;
17758 PyObject * obj2 = 0 ;
17759 PyObject * obj3 = 0 ;
17760 char * kwnames[] = {
17761 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17762 };
17763
17764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17766 if (!SWIG_IsOK(res1)) {
17767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17768 }
17769 arg1 = reinterpret_cast< wxImage * >(argp1);
17770 {
17771 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17772 arg2 = temp2->m_wxis;
17773 created2 = false;
17774 } else {
17775 PyErr_Clear(); // clear the failure of the wxPyConvert above
17776 arg2 = wxPyCBInputStream_create(obj1, false);
17777 if (arg2 == NULL) {
17778 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17779 SWIG_fail;
17780 }
17781 created2 = true;
17782 }
17783 }
17784 if (obj2) {
17785 ecode3 = SWIG_AsVal_long(obj2, &val3);
17786 if (!SWIG_IsOK(ecode3)) {
17787 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17788 }
17789 arg3 = static_cast< long >(val3);
17790 }
17791 if (obj3) {
17792 ecode4 = SWIG_AsVal_int(obj3, &val4);
17793 if (!SWIG_IsOK(ecode4)) {
17794 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17795 }
17796 arg4 = static_cast< int >(val4);
17797 }
17798 {
17799 PyThreadState* __tstate = wxPyBeginAllowThreads();
17800 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17801 wxPyEndAllowThreads(__tstate);
17802 if (PyErr_Occurred()) SWIG_fail;
17803 }
17804 {
17805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17806 }
17807 {
17808 if (created2) delete arg2;
17809 }
17810 return resultobj;
17811 fail:
17812 {
17813 if (created2) delete arg2;
17814 }
17815 return NULL;
17816 }
17817
17818
17819 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17820 PyObject *resultobj = 0;
17821 wxImage *arg1 = (wxImage *) 0 ;
17822 wxInputStream *arg2 = 0 ;
17823 wxString *arg3 = 0 ;
17824 int arg4 = (int) -1 ;
17825 bool result;
17826 void *argp1 = 0 ;
17827 int res1 = 0 ;
17828 wxPyInputStream *temp2 ;
17829 bool created2 ;
17830 bool temp3 = false ;
17831 int val4 ;
17832 int ecode4 = 0 ;
17833 PyObject * obj0 = 0 ;
17834 PyObject * obj1 = 0 ;
17835 PyObject * obj2 = 0 ;
17836 PyObject * obj3 = 0 ;
17837 char * kwnames[] = {
17838 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17839 };
17840
17841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17843 if (!SWIG_IsOK(res1)) {
17844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17845 }
17846 arg1 = reinterpret_cast< wxImage * >(argp1);
17847 {
17848 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17849 arg2 = temp2->m_wxis;
17850 created2 = false;
17851 } else {
17852 PyErr_Clear(); // clear the failure of the wxPyConvert above
17853 arg2 = wxPyCBInputStream_create(obj1, false);
17854 if (arg2 == NULL) {
17855 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17856 SWIG_fail;
17857 }
17858 created2 = true;
17859 }
17860 }
17861 {
17862 arg3 = wxString_in_helper(obj2);
17863 if (arg3 == NULL) SWIG_fail;
17864 temp3 = true;
17865 }
17866 if (obj3) {
17867 ecode4 = SWIG_AsVal_int(obj3, &val4);
17868 if (!SWIG_IsOK(ecode4)) {
17869 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17870 }
17871 arg4 = static_cast< int >(val4);
17872 }
17873 {
17874 PyThreadState* __tstate = wxPyBeginAllowThreads();
17875 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17876 wxPyEndAllowThreads(__tstate);
17877 if (PyErr_Occurred()) SWIG_fail;
17878 }
17879 {
17880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17881 }
17882 {
17883 if (created2) delete arg2;
17884 }
17885 {
17886 if (temp3)
17887 delete arg3;
17888 }
17889 return resultobj;
17890 fail:
17891 {
17892 if (created2) delete arg2;
17893 }
17894 {
17895 if (temp3)
17896 delete arg3;
17897 }
17898 return NULL;
17899 }
17900
17901
17902 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17903 PyObject *resultobj = 0;
17904 wxImage *arg1 = (wxImage *) 0 ;
17905 bool result;
17906 void *argp1 = 0 ;
17907 int res1 = 0 ;
17908 PyObject *swig_obj[1] ;
17909
17910 if (!args) SWIG_fail;
17911 swig_obj[0] = args;
17912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17913 if (!SWIG_IsOK(res1)) {
17914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
17915 }
17916 arg1 = reinterpret_cast< wxImage * >(argp1);
17917 {
17918 PyThreadState* __tstate = wxPyBeginAllowThreads();
17919 result = (bool)(arg1)->IsOk();
17920 wxPyEndAllowThreads(__tstate);
17921 if (PyErr_Occurred()) SWIG_fail;
17922 }
17923 {
17924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17925 }
17926 return resultobj;
17927 fail:
17928 return NULL;
17929 }
17930
17931
17932 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17933 PyObject *resultobj = 0;
17934 wxImage *arg1 = (wxImage *) 0 ;
17935 int result;
17936 void *argp1 = 0 ;
17937 int res1 = 0 ;
17938 PyObject *swig_obj[1] ;
17939
17940 if (!args) SWIG_fail;
17941 swig_obj[0] = args;
17942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17943 if (!SWIG_IsOK(res1)) {
17944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17945 }
17946 arg1 = reinterpret_cast< wxImage * >(argp1);
17947 {
17948 PyThreadState* __tstate = wxPyBeginAllowThreads();
17949 result = (int)(arg1)->GetWidth();
17950 wxPyEndAllowThreads(__tstate);
17951 if (PyErr_Occurred()) SWIG_fail;
17952 }
17953 resultobj = SWIG_From_int(static_cast< int >(result));
17954 return resultobj;
17955 fail:
17956 return NULL;
17957 }
17958
17959
17960 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17961 PyObject *resultobj = 0;
17962 wxImage *arg1 = (wxImage *) 0 ;
17963 int result;
17964 void *argp1 = 0 ;
17965 int res1 = 0 ;
17966 PyObject *swig_obj[1] ;
17967
17968 if (!args) SWIG_fail;
17969 swig_obj[0] = args;
17970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17971 if (!SWIG_IsOK(res1)) {
17972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17973 }
17974 arg1 = reinterpret_cast< wxImage * >(argp1);
17975 {
17976 PyThreadState* __tstate = wxPyBeginAllowThreads();
17977 result = (int)(arg1)->GetHeight();
17978 wxPyEndAllowThreads(__tstate);
17979 if (PyErr_Occurred()) SWIG_fail;
17980 }
17981 resultobj = SWIG_From_int(static_cast< int >(result));
17982 return resultobj;
17983 fail:
17984 return NULL;
17985 }
17986
17987
17988 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17989 PyObject *resultobj = 0;
17990 wxImage *arg1 = (wxImage *) 0 ;
17991 wxSize result;
17992 void *argp1 = 0 ;
17993 int res1 = 0 ;
17994 PyObject *swig_obj[1] ;
17995
17996 if (!args) SWIG_fail;
17997 swig_obj[0] = args;
17998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17999 if (!SWIG_IsOK(res1)) {
18000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
18001 }
18002 arg1 = reinterpret_cast< wxImage * >(argp1);
18003 {
18004 PyThreadState* __tstate = wxPyBeginAllowThreads();
18005 result = wxImage_GetSize(arg1);
18006 wxPyEndAllowThreads(__tstate);
18007 if (PyErr_Occurred()) SWIG_fail;
18008 }
18009 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
18010 return resultobj;
18011 fail:
18012 return NULL;
18013 }
18014
18015
18016 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18017 PyObject *resultobj = 0;
18018 wxImage *arg1 = (wxImage *) 0 ;
18019 wxRect *arg2 = 0 ;
18020 SwigValueWrapper<wxImage > result;
18021 void *argp1 = 0 ;
18022 int res1 = 0 ;
18023 wxRect temp2 ;
18024 PyObject * obj0 = 0 ;
18025 PyObject * obj1 = 0 ;
18026 char * kwnames[] = {
18027 (char *) "self",(char *) "rect", NULL
18028 };
18029
18030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
18031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18032 if (!SWIG_IsOK(res1)) {
18033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
18034 }
18035 arg1 = reinterpret_cast< wxImage * >(argp1);
18036 {
18037 arg2 = &temp2;
18038 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18039 }
18040 {
18041 PyThreadState* __tstate = wxPyBeginAllowThreads();
18042 result = (arg1)->GetSubImage((wxRect const &)*arg2);
18043 wxPyEndAllowThreads(__tstate);
18044 if (PyErr_Occurred()) SWIG_fail;
18045 }
18046 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18047 return resultobj;
18048 fail:
18049 return NULL;
18050 }
18051
18052
18053 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18054 PyObject *resultobj = 0;
18055 wxImage *arg1 = (wxImage *) 0 ;
18056 wxSize *arg2 = 0 ;
18057 wxPoint *arg3 = 0 ;
18058 int arg4 = (int) -1 ;
18059 int arg5 = (int) -1 ;
18060 int arg6 = (int) -1 ;
18061 SwigValueWrapper<wxImage > result;
18062 void *argp1 = 0 ;
18063 int res1 = 0 ;
18064 wxSize temp2 ;
18065 wxPoint temp3 ;
18066 int val4 ;
18067 int ecode4 = 0 ;
18068 int val5 ;
18069 int ecode5 = 0 ;
18070 int val6 ;
18071 int ecode6 = 0 ;
18072 PyObject * obj0 = 0 ;
18073 PyObject * obj1 = 0 ;
18074 PyObject * obj2 = 0 ;
18075 PyObject * obj3 = 0 ;
18076 PyObject * obj4 = 0 ;
18077 PyObject * obj5 = 0 ;
18078 char * kwnames[] = {
18079 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18080 };
18081
18082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18084 if (!SWIG_IsOK(res1)) {
18085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18086 }
18087 arg1 = reinterpret_cast< wxImage * >(argp1);
18088 {
18089 arg2 = &temp2;
18090 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18091 }
18092 {
18093 arg3 = &temp3;
18094 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18095 }
18096 if (obj3) {
18097 ecode4 = SWIG_AsVal_int(obj3, &val4);
18098 if (!SWIG_IsOK(ecode4)) {
18099 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18100 }
18101 arg4 = static_cast< int >(val4);
18102 }
18103 if (obj4) {
18104 ecode5 = SWIG_AsVal_int(obj4, &val5);
18105 if (!SWIG_IsOK(ecode5)) {
18106 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18107 }
18108 arg5 = static_cast< int >(val5);
18109 }
18110 if (obj5) {
18111 ecode6 = SWIG_AsVal_int(obj5, &val6);
18112 if (!SWIG_IsOK(ecode6)) {
18113 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18114 }
18115 arg6 = static_cast< int >(val6);
18116 }
18117 {
18118 PyThreadState* __tstate = wxPyBeginAllowThreads();
18119 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18120 wxPyEndAllowThreads(__tstate);
18121 if (PyErr_Occurred()) SWIG_fail;
18122 }
18123 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18124 return resultobj;
18125 fail:
18126 return NULL;
18127 }
18128
18129
18130 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18131 PyObject *resultobj = 0;
18132 wxImage *arg1 = (wxImage *) 0 ;
18133 SwigValueWrapper<wxImage > result;
18134 void *argp1 = 0 ;
18135 int res1 = 0 ;
18136 PyObject *swig_obj[1] ;
18137
18138 if (!args) SWIG_fail;
18139 swig_obj[0] = args;
18140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18141 if (!SWIG_IsOK(res1)) {
18142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18143 }
18144 arg1 = reinterpret_cast< wxImage * >(argp1);
18145 {
18146 PyThreadState* __tstate = wxPyBeginAllowThreads();
18147 result = (arg1)->Copy();
18148 wxPyEndAllowThreads(__tstate);
18149 if (PyErr_Occurred()) SWIG_fail;
18150 }
18151 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18152 return resultobj;
18153 fail:
18154 return NULL;
18155 }
18156
18157
18158 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18159 PyObject *resultobj = 0;
18160 wxImage *arg1 = (wxImage *) 0 ;
18161 wxImage *arg2 = 0 ;
18162 int arg3 ;
18163 int arg4 ;
18164 void *argp1 = 0 ;
18165 int res1 = 0 ;
18166 void *argp2 = 0 ;
18167 int res2 = 0 ;
18168 int val3 ;
18169 int ecode3 = 0 ;
18170 int val4 ;
18171 int ecode4 = 0 ;
18172 PyObject * obj0 = 0 ;
18173 PyObject * obj1 = 0 ;
18174 PyObject * obj2 = 0 ;
18175 PyObject * obj3 = 0 ;
18176 char * kwnames[] = {
18177 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18178 };
18179
18180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18182 if (!SWIG_IsOK(res1)) {
18183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18184 }
18185 arg1 = reinterpret_cast< wxImage * >(argp1);
18186 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18187 if (!SWIG_IsOK(res2)) {
18188 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18189 }
18190 if (!argp2) {
18191 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18192 }
18193 arg2 = reinterpret_cast< wxImage * >(argp2);
18194 ecode3 = SWIG_AsVal_int(obj2, &val3);
18195 if (!SWIG_IsOK(ecode3)) {
18196 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18197 }
18198 arg3 = static_cast< int >(val3);
18199 ecode4 = SWIG_AsVal_int(obj3, &val4);
18200 if (!SWIG_IsOK(ecode4)) {
18201 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18202 }
18203 arg4 = static_cast< int >(val4);
18204 {
18205 PyThreadState* __tstate = wxPyBeginAllowThreads();
18206 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18207 wxPyEndAllowThreads(__tstate);
18208 if (PyErr_Occurred()) SWIG_fail;
18209 }
18210 resultobj = SWIG_Py_Void();
18211 return resultobj;
18212 fail:
18213 return NULL;
18214 }
18215
18216
18217 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18218 PyObject *resultobj = 0;
18219 wxImage *arg1 = (wxImage *) 0 ;
18220 PyObject *result = 0 ;
18221 void *argp1 = 0 ;
18222 int res1 = 0 ;
18223 PyObject *swig_obj[1] ;
18224
18225 if (!args) SWIG_fail;
18226 swig_obj[0] = args;
18227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18228 if (!SWIG_IsOK(res1)) {
18229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18230 }
18231 arg1 = reinterpret_cast< wxImage * >(argp1);
18232 {
18233 PyThreadState* __tstate = wxPyBeginAllowThreads();
18234 result = (PyObject *)wxImage_GetData(arg1);
18235 wxPyEndAllowThreads(__tstate);
18236 if (PyErr_Occurred()) SWIG_fail;
18237 }
18238 resultobj = result;
18239 return resultobj;
18240 fail:
18241 return NULL;
18242 }
18243
18244
18245 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18246 PyObject *resultobj = 0;
18247 wxImage *arg1 = (wxImage *) 0 ;
18248 buffer arg2 ;
18249 int arg3 ;
18250 void *argp1 = 0 ;
18251 int res1 = 0 ;
18252 Py_ssize_t temp2 ;
18253 PyObject * obj0 = 0 ;
18254 PyObject * obj1 = 0 ;
18255 char * kwnames[] = {
18256 (char *) "self",(char *) "data", NULL
18257 };
18258
18259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18261 if (!SWIG_IsOK(res1)) {
18262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18263 }
18264 arg1 = reinterpret_cast< wxImage * >(argp1);
18265 {
18266 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18267 arg3 = (int)temp2;
18268 }
18269 {
18270 PyThreadState* __tstate = wxPyBeginAllowThreads();
18271 wxImage_SetData(arg1,arg2,arg3);
18272 wxPyEndAllowThreads(__tstate);
18273 if (PyErr_Occurred()) SWIG_fail;
18274 }
18275 resultobj = SWIG_Py_Void();
18276 return resultobj;
18277 fail:
18278 return NULL;
18279 }
18280
18281
18282 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18283 PyObject *resultobj = 0;
18284 wxImage *arg1 = (wxImage *) 0 ;
18285 PyObject *result = 0 ;
18286 void *argp1 = 0 ;
18287 int res1 = 0 ;
18288 PyObject *swig_obj[1] ;
18289
18290 if (!args) SWIG_fail;
18291 swig_obj[0] = args;
18292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18293 if (!SWIG_IsOK(res1)) {
18294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18295 }
18296 arg1 = reinterpret_cast< wxImage * >(argp1);
18297 {
18298 PyThreadState* __tstate = wxPyBeginAllowThreads();
18299 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18300 wxPyEndAllowThreads(__tstate);
18301 if (PyErr_Occurred()) SWIG_fail;
18302 }
18303 resultobj = result;
18304 return resultobj;
18305 fail:
18306 return NULL;
18307 }
18308
18309
18310 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18311 PyObject *resultobj = 0;
18312 wxImage *arg1 = (wxImage *) 0 ;
18313 buffer arg2 ;
18314 int arg3 ;
18315 void *argp1 = 0 ;
18316 int res1 = 0 ;
18317 Py_ssize_t temp2 ;
18318 PyObject * obj0 = 0 ;
18319 PyObject * obj1 = 0 ;
18320 char * kwnames[] = {
18321 (char *) "self",(char *) "data", NULL
18322 };
18323
18324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18326 if (!SWIG_IsOK(res1)) {
18327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18328 }
18329 arg1 = reinterpret_cast< wxImage * >(argp1);
18330 {
18331 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18332 arg3 = (int)temp2;
18333 }
18334 {
18335 PyThreadState* __tstate = wxPyBeginAllowThreads();
18336 wxImage_SetDataBuffer(arg1,arg2,arg3);
18337 wxPyEndAllowThreads(__tstate);
18338 if (PyErr_Occurred()) SWIG_fail;
18339 }
18340 resultobj = SWIG_Py_Void();
18341 return resultobj;
18342 fail:
18343 return NULL;
18344 }
18345
18346
18347 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18348 PyObject *resultobj = 0;
18349 wxImage *arg1 = (wxImage *) 0 ;
18350 PyObject *result = 0 ;
18351 void *argp1 = 0 ;
18352 int res1 = 0 ;
18353 PyObject *swig_obj[1] ;
18354
18355 if (!args) SWIG_fail;
18356 swig_obj[0] = args;
18357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18358 if (!SWIG_IsOK(res1)) {
18359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18360 }
18361 arg1 = reinterpret_cast< wxImage * >(argp1);
18362 {
18363 PyThreadState* __tstate = wxPyBeginAllowThreads();
18364 result = (PyObject *)wxImage_GetAlphaData(arg1);
18365 wxPyEndAllowThreads(__tstate);
18366 if (PyErr_Occurred()) SWIG_fail;
18367 }
18368 resultobj = result;
18369 return resultobj;
18370 fail:
18371 return NULL;
18372 }
18373
18374
18375 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18376 PyObject *resultobj = 0;
18377 wxImage *arg1 = (wxImage *) 0 ;
18378 buffer arg2 ;
18379 int arg3 ;
18380 void *argp1 = 0 ;
18381 int res1 = 0 ;
18382 Py_ssize_t temp2 ;
18383 PyObject * obj0 = 0 ;
18384 PyObject * obj1 = 0 ;
18385 char * kwnames[] = {
18386 (char *) "self",(char *) "alpha", NULL
18387 };
18388
18389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18391 if (!SWIG_IsOK(res1)) {
18392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18393 }
18394 arg1 = reinterpret_cast< wxImage * >(argp1);
18395 {
18396 if (obj1 != Py_None) {
18397 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18398 arg3 = (int)temp2;
18399 }
18400 }
18401 {
18402 PyThreadState* __tstate = wxPyBeginAllowThreads();
18403 wxImage_SetAlphaData(arg1,arg2,arg3);
18404 wxPyEndAllowThreads(__tstate);
18405 if (PyErr_Occurred()) SWIG_fail;
18406 }
18407 resultobj = SWIG_Py_Void();
18408 return resultobj;
18409 fail:
18410 return NULL;
18411 }
18412
18413
18414 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18415 PyObject *resultobj = 0;
18416 wxImage *arg1 = (wxImage *) 0 ;
18417 PyObject *result = 0 ;
18418 void *argp1 = 0 ;
18419 int res1 = 0 ;
18420 PyObject *swig_obj[1] ;
18421
18422 if (!args) SWIG_fail;
18423 swig_obj[0] = args;
18424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18425 if (!SWIG_IsOK(res1)) {
18426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18427 }
18428 arg1 = reinterpret_cast< wxImage * >(argp1);
18429 {
18430 PyThreadState* __tstate = wxPyBeginAllowThreads();
18431 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18432 wxPyEndAllowThreads(__tstate);
18433 if (PyErr_Occurred()) SWIG_fail;
18434 }
18435 resultobj = result;
18436 return resultobj;
18437 fail:
18438 return NULL;
18439 }
18440
18441
18442 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18443 PyObject *resultobj = 0;
18444 wxImage *arg1 = (wxImage *) 0 ;
18445 buffer arg2 ;
18446 int arg3 ;
18447 void *argp1 = 0 ;
18448 int res1 = 0 ;
18449 Py_ssize_t temp2 ;
18450 PyObject * obj0 = 0 ;
18451 PyObject * obj1 = 0 ;
18452 char * kwnames[] = {
18453 (char *) "self",(char *) "alpha", NULL
18454 };
18455
18456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18458 if (!SWIG_IsOK(res1)) {
18459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18460 }
18461 arg1 = reinterpret_cast< wxImage * >(argp1);
18462 {
18463 if (obj1 != Py_None) {
18464 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18465 arg3 = (int)temp2;
18466 }
18467 }
18468 {
18469 PyThreadState* __tstate = wxPyBeginAllowThreads();
18470 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18471 wxPyEndAllowThreads(__tstate);
18472 if (PyErr_Occurred()) SWIG_fail;
18473 }
18474 resultobj = SWIG_Py_Void();
18475 return resultobj;
18476 fail:
18477 return NULL;
18478 }
18479
18480
18481 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18482 PyObject *resultobj = 0;
18483 wxImage *arg1 = (wxImage *) 0 ;
18484 byte arg2 ;
18485 byte arg3 ;
18486 byte arg4 ;
18487 void *argp1 = 0 ;
18488 int res1 = 0 ;
18489 unsigned char val2 ;
18490 int ecode2 = 0 ;
18491 unsigned char val3 ;
18492 int ecode3 = 0 ;
18493 unsigned char val4 ;
18494 int ecode4 = 0 ;
18495 PyObject * obj0 = 0 ;
18496 PyObject * obj1 = 0 ;
18497 PyObject * obj2 = 0 ;
18498 PyObject * obj3 = 0 ;
18499 char * kwnames[] = {
18500 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18501 };
18502
18503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18505 if (!SWIG_IsOK(res1)) {
18506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18507 }
18508 arg1 = reinterpret_cast< wxImage * >(argp1);
18509 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18510 if (!SWIG_IsOK(ecode2)) {
18511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18512 }
18513 arg2 = static_cast< byte >(val2);
18514 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18515 if (!SWIG_IsOK(ecode3)) {
18516 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18517 }
18518 arg3 = static_cast< byte >(val3);
18519 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18520 if (!SWIG_IsOK(ecode4)) {
18521 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18522 }
18523 arg4 = static_cast< byte >(val4);
18524 {
18525 PyThreadState* __tstate = wxPyBeginAllowThreads();
18526 (arg1)->SetMaskColour(arg2,arg3,arg4);
18527 wxPyEndAllowThreads(__tstate);
18528 if (PyErr_Occurred()) SWIG_fail;
18529 }
18530 resultobj = SWIG_Py_Void();
18531 return resultobj;
18532 fail:
18533 return NULL;
18534 }
18535
18536
18537 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18538 PyObject *resultobj = 0;
18539 wxImage *arg1 = (wxImage *) 0 ;
18540 byte *arg2 = (byte *) 0 ;
18541 byte *arg3 = (byte *) 0 ;
18542 byte *arg4 = (byte *) 0 ;
18543 void *argp1 = 0 ;
18544 int res1 = 0 ;
18545 byte temp2 ;
18546 int res2 = SWIG_TMPOBJ ;
18547 byte temp3 ;
18548 int res3 = SWIG_TMPOBJ ;
18549 byte temp4 ;
18550 int res4 = SWIG_TMPOBJ ;
18551 PyObject *swig_obj[1] ;
18552
18553 arg2 = &temp2;
18554 arg3 = &temp3;
18555 arg4 = &temp4;
18556 if (!args) SWIG_fail;
18557 swig_obj[0] = args;
18558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18559 if (!SWIG_IsOK(res1)) {
18560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18561 }
18562 arg1 = reinterpret_cast< wxImage * >(argp1);
18563 {
18564 PyThreadState* __tstate = wxPyBeginAllowThreads();
18565 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18566 wxPyEndAllowThreads(__tstate);
18567 if (PyErr_Occurred()) SWIG_fail;
18568 }
18569 resultobj = SWIG_Py_Void();
18570 if (SWIG_IsTmpObj(res2)) {
18571 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18572 } else {
18573 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18574 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18575 }
18576 if (SWIG_IsTmpObj(res3)) {
18577 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18578 } else {
18579 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18580 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18581 }
18582 if (SWIG_IsTmpObj(res4)) {
18583 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18584 } else {
18585 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18586 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18587 }
18588 return resultobj;
18589 fail:
18590 return NULL;
18591 }
18592
18593
18594 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18595 PyObject *resultobj = 0;
18596 wxImage *arg1 = (wxImage *) 0 ;
18597 byte result;
18598 void *argp1 = 0 ;
18599 int res1 = 0 ;
18600 PyObject *swig_obj[1] ;
18601
18602 if (!args) SWIG_fail;
18603 swig_obj[0] = args;
18604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18605 if (!SWIG_IsOK(res1)) {
18606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18607 }
18608 arg1 = reinterpret_cast< wxImage * >(argp1);
18609 {
18610 PyThreadState* __tstate = wxPyBeginAllowThreads();
18611 result = (byte)(arg1)->GetMaskRed();
18612 wxPyEndAllowThreads(__tstate);
18613 if (PyErr_Occurred()) SWIG_fail;
18614 }
18615 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18616 return resultobj;
18617 fail:
18618 return NULL;
18619 }
18620
18621
18622 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18623 PyObject *resultobj = 0;
18624 wxImage *arg1 = (wxImage *) 0 ;
18625 byte result;
18626 void *argp1 = 0 ;
18627 int res1 = 0 ;
18628 PyObject *swig_obj[1] ;
18629
18630 if (!args) SWIG_fail;
18631 swig_obj[0] = args;
18632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18633 if (!SWIG_IsOK(res1)) {
18634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18635 }
18636 arg1 = reinterpret_cast< wxImage * >(argp1);
18637 {
18638 PyThreadState* __tstate = wxPyBeginAllowThreads();
18639 result = (byte)(arg1)->GetMaskGreen();
18640 wxPyEndAllowThreads(__tstate);
18641 if (PyErr_Occurred()) SWIG_fail;
18642 }
18643 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18644 return resultobj;
18645 fail:
18646 return NULL;
18647 }
18648
18649
18650 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18651 PyObject *resultobj = 0;
18652 wxImage *arg1 = (wxImage *) 0 ;
18653 byte result;
18654 void *argp1 = 0 ;
18655 int res1 = 0 ;
18656 PyObject *swig_obj[1] ;
18657
18658 if (!args) SWIG_fail;
18659 swig_obj[0] = args;
18660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18661 if (!SWIG_IsOK(res1)) {
18662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18663 }
18664 arg1 = reinterpret_cast< wxImage * >(argp1);
18665 {
18666 PyThreadState* __tstate = wxPyBeginAllowThreads();
18667 result = (byte)(arg1)->GetMaskBlue();
18668 wxPyEndAllowThreads(__tstate);
18669 if (PyErr_Occurred()) SWIG_fail;
18670 }
18671 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18672 return resultobj;
18673 fail:
18674 return NULL;
18675 }
18676
18677
18678 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18679 PyObject *resultobj = 0;
18680 wxImage *arg1 = (wxImage *) 0 ;
18681 bool arg2 = (bool) true ;
18682 void *argp1 = 0 ;
18683 int res1 = 0 ;
18684 bool val2 ;
18685 int ecode2 = 0 ;
18686 PyObject * obj0 = 0 ;
18687 PyObject * obj1 = 0 ;
18688 char * kwnames[] = {
18689 (char *) "self",(char *) "mask", NULL
18690 };
18691
18692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18694 if (!SWIG_IsOK(res1)) {
18695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18696 }
18697 arg1 = reinterpret_cast< wxImage * >(argp1);
18698 if (obj1) {
18699 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18700 if (!SWIG_IsOK(ecode2)) {
18701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18702 }
18703 arg2 = static_cast< bool >(val2);
18704 }
18705 {
18706 PyThreadState* __tstate = wxPyBeginAllowThreads();
18707 (arg1)->SetMask(arg2);
18708 wxPyEndAllowThreads(__tstate);
18709 if (PyErr_Occurred()) SWIG_fail;
18710 }
18711 resultobj = SWIG_Py_Void();
18712 return resultobj;
18713 fail:
18714 return NULL;
18715 }
18716
18717
18718 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18719 PyObject *resultobj = 0;
18720 wxImage *arg1 = (wxImage *) 0 ;
18721 bool result;
18722 void *argp1 = 0 ;
18723 int res1 = 0 ;
18724 PyObject *swig_obj[1] ;
18725
18726 if (!args) SWIG_fail;
18727 swig_obj[0] = args;
18728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18729 if (!SWIG_IsOK(res1)) {
18730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18731 }
18732 arg1 = reinterpret_cast< wxImage * >(argp1);
18733 {
18734 PyThreadState* __tstate = wxPyBeginAllowThreads();
18735 result = (bool)(arg1)->HasMask();
18736 wxPyEndAllowThreads(__tstate);
18737 if (PyErr_Occurred()) SWIG_fail;
18738 }
18739 {
18740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18741 }
18742 return resultobj;
18743 fail:
18744 return NULL;
18745 }
18746
18747
18748 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18749 PyObject *resultobj = 0;
18750 wxImage *arg1 = (wxImage *) 0 ;
18751 double arg2 ;
18752 wxPoint *arg3 = 0 ;
18753 bool arg4 = (bool) true ;
18754 wxPoint *arg5 = (wxPoint *) NULL ;
18755 SwigValueWrapper<wxImage > result;
18756 void *argp1 = 0 ;
18757 int res1 = 0 ;
18758 double val2 ;
18759 int ecode2 = 0 ;
18760 wxPoint temp3 ;
18761 bool val4 ;
18762 int ecode4 = 0 ;
18763 void *argp5 = 0 ;
18764 int res5 = 0 ;
18765 PyObject * obj0 = 0 ;
18766 PyObject * obj1 = 0 ;
18767 PyObject * obj2 = 0 ;
18768 PyObject * obj3 = 0 ;
18769 PyObject * obj4 = 0 ;
18770 char * kwnames[] = {
18771 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18772 };
18773
18774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18776 if (!SWIG_IsOK(res1)) {
18777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18778 }
18779 arg1 = reinterpret_cast< wxImage * >(argp1);
18780 ecode2 = SWIG_AsVal_double(obj1, &val2);
18781 if (!SWIG_IsOK(ecode2)) {
18782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18783 }
18784 arg2 = static_cast< double >(val2);
18785 {
18786 arg3 = &temp3;
18787 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18788 }
18789 if (obj3) {
18790 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18791 if (!SWIG_IsOK(ecode4)) {
18792 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18793 }
18794 arg4 = static_cast< bool >(val4);
18795 }
18796 if (obj4) {
18797 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18798 if (!SWIG_IsOK(res5)) {
18799 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
18800 }
18801 arg5 = reinterpret_cast< wxPoint * >(argp5);
18802 }
18803 {
18804 PyThreadState* __tstate = wxPyBeginAllowThreads();
18805 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18806 wxPyEndAllowThreads(__tstate);
18807 if (PyErr_Occurred()) SWIG_fail;
18808 }
18809 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18810 return resultobj;
18811 fail:
18812 return NULL;
18813 }
18814
18815
18816 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18817 PyObject *resultobj = 0;
18818 wxImage *arg1 = (wxImage *) 0 ;
18819 bool arg2 = (bool) true ;
18820 SwigValueWrapper<wxImage > result;
18821 void *argp1 = 0 ;
18822 int res1 = 0 ;
18823 bool val2 ;
18824 int ecode2 = 0 ;
18825 PyObject * obj0 = 0 ;
18826 PyObject * obj1 = 0 ;
18827 char * kwnames[] = {
18828 (char *) "self",(char *) "clockwise", NULL
18829 };
18830
18831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18833 if (!SWIG_IsOK(res1)) {
18834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18835 }
18836 arg1 = reinterpret_cast< wxImage * >(argp1);
18837 if (obj1) {
18838 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18839 if (!SWIG_IsOK(ecode2)) {
18840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18841 }
18842 arg2 = static_cast< bool >(val2);
18843 }
18844 {
18845 PyThreadState* __tstate = wxPyBeginAllowThreads();
18846 result = (arg1)->Rotate90(arg2);
18847 wxPyEndAllowThreads(__tstate);
18848 if (PyErr_Occurred()) SWIG_fail;
18849 }
18850 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18851 return resultobj;
18852 fail:
18853 return NULL;
18854 }
18855
18856
18857 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18858 PyObject *resultobj = 0;
18859 wxImage *arg1 = (wxImage *) 0 ;
18860 bool arg2 = (bool) true ;
18861 SwigValueWrapper<wxImage > result;
18862 void *argp1 = 0 ;
18863 int res1 = 0 ;
18864 bool val2 ;
18865 int ecode2 = 0 ;
18866 PyObject * obj0 = 0 ;
18867 PyObject * obj1 = 0 ;
18868 char * kwnames[] = {
18869 (char *) "self",(char *) "horizontally", NULL
18870 };
18871
18872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18874 if (!SWIG_IsOK(res1)) {
18875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18876 }
18877 arg1 = reinterpret_cast< wxImage * >(argp1);
18878 if (obj1) {
18879 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18880 if (!SWIG_IsOK(ecode2)) {
18881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18882 }
18883 arg2 = static_cast< bool >(val2);
18884 }
18885 {
18886 PyThreadState* __tstate = wxPyBeginAllowThreads();
18887 result = (arg1)->Mirror(arg2);
18888 wxPyEndAllowThreads(__tstate);
18889 if (PyErr_Occurred()) SWIG_fail;
18890 }
18891 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18892 return resultobj;
18893 fail:
18894 return NULL;
18895 }
18896
18897
18898 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18899 PyObject *resultobj = 0;
18900 wxImage *arg1 = (wxImage *) 0 ;
18901 byte arg2 ;
18902 byte arg3 ;
18903 byte arg4 ;
18904 byte arg5 ;
18905 byte arg6 ;
18906 byte arg7 ;
18907 void *argp1 = 0 ;
18908 int res1 = 0 ;
18909 unsigned char val2 ;
18910 int ecode2 = 0 ;
18911 unsigned char val3 ;
18912 int ecode3 = 0 ;
18913 unsigned char val4 ;
18914 int ecode4 = 0 ;
18915 unsigned char val5 ;
18916 int ecode5 = 0 ;
18917 unsigned char val6 ;
18918 int ecode6 = 0 ;
18919 unsigned char val7 ;
18920 int ecode7 = 0 ;
18921 PyObject * obj0 = 0 ;
18922 PyObject * obj1 = 0 ;
18923 PyObject * obj2 = 0 ;
18924 PyObject * obj3 = 0 ;
18925 PyObject * obj4 = 0 ;
18926 PyObject * obj5 = 0 ;
18927 PyObject * obj6 = 0 ;
18928 char * kwnames[] = {
18929 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18930 };
18931
18932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18934 if (!SWIG_IsOK(res1)) {
18935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18936 }
18937 arg1 = reinterpret_cast< wxImage * >(argp1);
18938 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18939 if (!SWIG_IsOK(ecode2)) {
18940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18941 }
18942 arg2 = static_cast< byte >(val2);
18943 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18944 if (!SWIG_IsOK(ecode3)) {
18945 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18946 }
18947 arg3 = static_cast< byte >(val3);
18948 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18949 if (!SWIG_IsOK(ecode4)) {
18950 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18951 }
18952 arg4 = static_cast< byte >(val4);
18953 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18954 if (!SWIG_IsOK(ecode5)) {
18955 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18956 }
18957 arg5 = static_cast< byte >(val5);
18958 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18959 if (!SWIG_IsOK(ecode6)) {
18960 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18961 }
18962 arg6 = static_cast< byte >(val6);
18963 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18964 if (!SWIG_IsOK(ecode7)) {
18965 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18966 }
18967 arg7 = static_cast< byte >(val7);
18968 {
18969 PyThreadState* __tstate = wxPyBeginAllowThreads();
18970 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18971 wxPyEndAllowThreads(__tstate);
18972 if (PyErr_Occurred()) SWIG_fail;
18973 }
18974 resultobj = SWIG_Py_Void();
18975 return resultobj;
18976 fail:
18977 return NULL;
18978 }
18979
18980
18981 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18982 PyObject *resultobj = 0;
18983 wxImage *arg1 = (wxImage *) 0 ;
18984 double arg2 = (double) 0.299 ;
18985 double arg3 = (double) 0.587 ;
18986 double arg4 = (double) 0.114 ;
18987 SwigValueWrapper<wxImage > result;
18988 void *argp1 = 0 ;
18989 int res1 = 0 ;
18990 double val2 ;
18991 int ecode2 = 0 ;
18992 double val3 ;
18993 int ecode3 = 0 ;
18994 double val4 ;
18995 int ecode4 = 0 ;
18996 PyObject * obj0 = 0 ;
18997 PyObject * obj1 = 0 ;
18998 PyObject * obj2 = 0 ;
18999 PyObject * obj3 = 0 ;
19000 char * kwnames[] = {
19001 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
19002 };
19003
19004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19006 if (!SWIG_IsOK(res1)) {
19007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
19008 }
19009 arg1 = reinterpret_cast< wxImage * >(argp1);
19010 if (obj1) {
19011 ecode2 = SWIG_AsVal_double(obj1, &val2);
19012 if (!SWIG_IsOK(ecode2)) {
19013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
19014 }
19015 arg2 = static_cast< double >(val2);
19016 }
19017 if (obj2) {
19018 ecode3 = SWIG_AsVal_double(obj2, &val3);
19019 if (!SWIG_IsOK(ecode3)) {
19020 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
19021 }
19022 arg3 = static_cast< double >(val3);
19023 }
19024 if (obj3) {
19025 ecode4 = SWIG_AsVal_double(obj3, &val4);
19026 if (!SWIG_IsOK(ecode4)) {
19027 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
19028 }
19029 arg4 = static_cast< double >(val4);
19030 }
19031 {
19032 PyThreadState* __tstate = wxPyBeginAllowThreads();
19033 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
19034 wxPyEndAllowThreads(__tstate);
19035 if (PyErr_Occurred()) SWIG_fail;
19036 }
19037 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19038 return resultobj;
19039 fail:
19040 return NULL;
19041 }
19042
19043
19044 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19045 PyObject *resultobj = 0;
19046 wxImage *arg1 = (wxImage *) 0 ;
19047 byte arg2 ;
19048 byte arg3 ;
19049 byte arg4 ;
19050 SwigValueWrapper<wxImage > result;
19051 void *argp1 = 0 ;
19052 int res1 = 0 ;
19053 unsigned char val2 ;
19054 int ecode2 = 0 ;
19055 unsigned char val3 ;
19056 int ecode3 = 0 ;
19057 unsigned char val4 ;
19058 int ecode4 = 0 ;
19059 PyObject * obj0 = 0 ;
19060 PyObject * obj1 = 0 ;
19061 PyObject * obj2 = 0 ;
19062 PyObject * obj3 = 0 ;
19063 char * kwnames[] = {
19064 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19065 };
19066
19067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19069 if (!SWIG_IsOK(res1)) {
19070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19071 }
19072 arg1 = reinterpret_cast< wxImage * >(argp1);
19073 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19074 if (!SWIG_IsOK(ecode2)) {
19075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19076 }
19077 arg2 = static_cast< byte >(val2);
19078 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19079 if (!SWIG_IsOK(ecode3)) {
19080 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19081 }
19082 arg3 = static_cast< byte >(val3);
19083 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19084 if (!SWIG_IsOK(ecode4)) {
19085 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19086 }
19087 arg4 = static_cast< byte >(val4);
19088 {
19089 PyThreadState* __tstate = wxPyBeginAllowThreads();
19090 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19091 wxPyEndAllowThreads(__tstate);
19092 if (PyErr_Occurred()) SWIG_fail;
19093 }
19094 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19095 return resultobj;
19096 fail:
19097 return NULL;
19098 }
19099
19100
19101 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19102 PyObject *resultobj = 0;
19103 wxImage *arg1 = (wxImage *) 0 ;
19104 wxString *arg2 = 0 ;
19105 wxString *arg3 = 0 ;
19106 void *argp1 = 0 ;
19107 int res1 = 0 ;
19108 bool temp2 = false ;
19109 bool temp3 = false ;
19110 PyObject * obj0 = 0 ;
19111 PyObject * obj1 = 0 ;
19112 PyObject * obj2 = 0 ;
19113 char * kwnames[] = {
19114 (char *) "self",(char *) "name",(char *) "value", NULL
19115 };
19116
19117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19119 if (!SWIG_IsOK(res1)) {
19120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19121 }
19122 arg1 = reinterpret_cast< wxImage * >(argp1);
19123 {
19124 arg2 = wxString_in_helper(obj1);
19125 if (arg2 == NULL) SWIG_fail;
19126 temp2 = true;
19127 }
19128 {
19129 arg3 = wxString_in_helper(obj2);
19130 if (arg3 == NULL) SWIG_fail;
19131 temp3 = true;
19132 }
19133 {
19134 PyThreadState* __tstate = wxPyBeginAllowThreads();
19135 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19136 wxPyEndAllowThreads(__tstate);
19137 if (PyErr_Occurred()) SWIG_fail;
19138 }
19139 resultobj = SWIG_Py_Void();
19140 {
19141 if (temp2)
19142 delete arg2;
19143 }
19144 {
19145 if (temp3)
19146 delete arg3;
19147 }
19148 return resultobj;
19149 fail:
19150 {
19151 if (temp2)
19152 delete arg2;
19153 }
19154 {
19155 if (temp3)
19156 delete arg3;
19157 }
19158 return NULL;
19159 }
19160
19161
19162 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19163 PyObject *resultobj = 0;
19164 wxImage *arg1 = (wxImage *) 0 ;
19165 wxString *arg2 = 0 ;
19166 int arg3 ;
19167 void *argp1 = 0 ;
19168 int res1 = 0 ;
19169 bool temp2 = false ;
19170 int val3 ;
19171 int ecode3 = 0 ;
19172 PyObject * obj0 = 0 ;
19173 PyObject * obj1 = 0 ;
19174 PyObject * obj2 = 0 ;
19175 char * kwnames[] = {
19176 (char *) "self",(char *) "name",(char *) "value", NULL
19177 };
19178
19179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19181 if (!SWIG_IsOK(res1)) {
19182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19183 }
19184 arg1 = reinterpret_cast< wxImage * >(argp1);
19185 {
19186 arg2 = wxString_in_helper(obj1);
19187 if (arg2 == NULL) SWIG_fail;
19188 temp2 = true;
19189 }
19190 ecode3 = SWIG_AsVal_int(obj2, &val3);
19191 if (!SWIG_IsOK(ecode3)) {
19192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19193 }
19194 arg3 = static_cast< int >(val3);
19195 {
19196 PyThreadState* __tstate = wxPyBeginAllowThreads();
19197 (arg1)->SetOption((wxString const &)*arg2,arg3);
19198 wxPyEndAllowThreads(__tstate);
19199 if (PyErr_Occurred()) SWIG_fail;
19200 }
19201 resultobj = SWIG_Py_Void();
19202 {
19203 if (temp2)
19204 delete arg2;
19205 }
19206 return resultobj;
19207 fail:
19208 {
19209 if (temp2)
19210 delete arg2;
19211 }
19212 return NULL;
19213 }
19214
19215
19216 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19217 PyObject *resultobj = 0;
19218 wxImage *arg1 = (wxImage *) 0 ;
19219 wxString *arg2 = 0 ;
19220 wxString result;
19221 void *argp1 = 0 ;
19222 int res1 = 0 ;
19223 bool temp2 = false ;
19224 PyObject * obj0 = 0 ;
19225 PyObject * obj1 = 0 ;
19226 char * kwnames[] = {
19227 (char *) "self",(char *) "name", NULL
19228 };
19229
19230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19232 if (!SWIG_IsOK(res1)) {
19233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19234 }
19235 arg1 = reinterpret_cast< wxImage * >(argp1);
19236 {
19237 arg2 = wxString_in_helper(obj1);
19238 if (arg2 == NULL) SWIG_fail;
19239 temp2 = true;
19240 }
19241 {
19242 PyThreadState* __tstate = wxPyBeginAllowThreads();
19243 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19244 wxPyEndAllowThreads(__tstate);
19245 if (PyErr_Occurred()) SWIG_fail;
19246 }
19247 {
19248 #if wxUSE_UNICODE
19249 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19250 #else
19251 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19252 #endif
19253 }
19254 {
19255 if (temp2)
19256 delete arg2;
19257 }
19258 return resultobj;
19259 fail:
19260 {
19261 if (temp2)
19262 delete arg2;
19263 }
19264 return NULL;
19265 }
19266
19267
19268 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19269 PyObject *resultobj = 0;
19270 wxImage *arg1 = (wxImage *) 0 ;
19271 wxString *arg2 = 0 ;
19272 int result;
19273 void *argp1 = 0 ;
19274 int res1 = 0 ;
19275 bool temp2 = false ;
19276 PyObject * obj0 = 0 ;
19277 PyObject * obj1 = 0 ;
19278 char * kwnames[] = {
19279 (char *) "self",(char *) "name", NULL
19280 };
19281
19282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19284 if (!SWIG_IsOK(res1)) {
19285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19286 }
19287 arg1 = reinterpret_cast< wxImage * >(argp1);
19288 {
19289 arg2 = wxString_in_helper(obj1);
19290 if (arg2 == NULL) SWIG_fail;
19291 temp2 = true;
19292 }
19293 {
19294 PyThreadState* __tstate = wxPyBeginAllowThreads();
19295 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19296 wxPyEndAllowThreads(__tstate);
19297 if (PyErr_Occurred()) SWIG_fail;
19298 }
19299 resultobj = SWIG_From_int(static_cast< int >(result));
19300 {
19301 if (temp2)
19302 delete arg2;
19303 }
19304 return resultobj;
19305 fail:
19306 {
19307 if (temp2)
19308 delete arg2;
19309 }
19310 return NULL;
19311 }
19312
19313
19314 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19315 PyObject *resultobj = 0;
19316 wxImage *arg1 = (wxImage *) 0 ;
19317 wxString *arg2 = 0 ;
19318 bool result;
19319 void *argp1 = 0 ;
19320 int res1 = 0 ;
19321 bool temp2 = false ;
19322 PyObject * obj0 = 0 ;
19323 PyObject * obj1 = 0 ;
19324 char * kwnames[] = {
19325 (char *) "self",(char *) "name", NULL
19326 };
19327
19328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19330 if (!SWIG_IsOK(res1)) {
19331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19332 }
19333 arg1 = reinterpret_cast< wxImage * >(argp1);
19334 {
19335 arg2 = wxString_in_helper(obj1);
19336 if (arg2 == NULL) SWIG_fail;
19337 temp2 = true;
19338 }
19339 {
19340 PyThreadState* __tstate = wxPyBeginAllowThreads();
19341 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19342 wxPyEndAllowThreads(__tstate);
19343 if (PyErr_Occurred()) SWIG_fail;
19344 }
19345 {
19346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19347 }
19348 {
19349 if (temp2)
19350 delete arg2;
19351 }
19352 return resultobj;
19353 fail:
19354 {
19355 if (temp2)
19356 delete arg2;
19357 }
19358 return NULL;
19359 }
19360
19361
19362 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19363 PyObject *resultobj = 0;
19364 wxImage *arg1 = (wxImage *) 0 ;
19365 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19366 unsigned long result;
19367 void *argp1 = 0 ;
19368 int res1 = 0 ;
19369 unsigned long val2 ;
19370 int ecode2 = 0 ;
19371 PyObject * obj0 = 0 ;
19372 PyObject * obj1 = 0 ;
19373 char * kwnames[] = {
19374 (char *) "self",(char *) "stopafter", NULL
19375 };
19376
19377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19379 if (!SWIG_IsOK(res1)) {
19380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19381 }
19382 arg1 = reinterpret_cast< wxImage * >(argp1);
19383 if (obj1) {
19384 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19385 if (!SWIG_IsOK(ecode2)) {
19386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19387 }
19388 arg2 = static_cast< unsigned long >(val2);
19389 }
19390 {
19391 PyThreadState* __tstate = wxPyBeginAllowThreads();
19392 result = (unsigned long)(arg1)->CountColours(arg2);
19393 wxPyEndAllowThreads(__tstate);
19394 if (PyErr_Occurred()) SWIG_fail;
19395 }
19396 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19397 return resultobj;
19398 fail:
19399 return NULL;
19400 }
19401
19402
19403 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19404 PyObject *resultobj = 0;
19405 wxImage *arg1 = (wxImage *) 0 ;
19406 wxImageHistogram *arg2 = 0 ;
19407 unsigned long result;
19408 void *argp1 = 0 ;
19409 int res1 = 0 ;
19410 void *argp2 = 0 ;
19411 int res2 = 0 ;
19412 PyObject * obj0 = 0 ;
19413 PyObject * obj1 = 0 ;
19414 char * kwnames[] = {
19415 (char *) "self",(char *) "h", NULL
19416 };
19417
19418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19420 if (!SWIG_IsOK(res1)) {
19421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19422 }
19423 arg1 = reinterpret_cast< wxImage * >(argp1);
19424 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19425 if (!SWIG_IsOK(res2)) {
19426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19427 }
19428 if (!argp2) {
19429 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19430 }
19431 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19432 {
19433 PyThreadState* __tstate = wxPyBeginAllowThreads();
19434 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19435 wxPyEndAllowThreads(__tstate);
19436 if (PyErr_Occurred()) SWIG_fail;
19437 }
19438 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19439 return resultobj;
19440 fail:
19441 return NULL;
19442 }
19443
19444
19445 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19446 PyObject *resultobj = 0;
19447 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19448 void *argp1 = 0 ;
19449 int res1 = 0 ;
19450 PyObject * obj0 = 0 ;
19451 char * kwnames[] = {
19452 (char *) "handler", NULL
19453 };
19454
19455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19457 if (!SWIG_IsOK(res1)) {
19458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19459 }
19460 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19461 {
19462 PyThreadState* __tstate = wxPyBeginAllowThreads();
19463 wxImage::AddHandler(arg1);
19464 wxPyEndAllowThreads(__tstate);
19465 if (PyErr_Occurred()) SWIG_fail;
19466 }
19467 resultobj = SWIG_Py_Void();
19468 return resultobj;
19469 fail:
19470 return NULL;
19471 }
19472
19473
19474 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19475 PyObject *resultobj = 0;
19476 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19477 void *argp1 = 0 ;
19478 int res1 = 0 ;
19479 PyObject * obj0 = 0 ;
19480 char * kwnames[] = {
19481 (char *) "handler", NULL
19482 };
19483
19484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19486 if (!SWIG_IsOK(res1)) {
19487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19488 }
19489 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19490 {
19491 PyThreadState* __tstate = wxPyBeginAllowThreads();
19492 wxImage::InsertHandler(arg1);
19493 wxPyEndAllowThreads(__tstate);
19494 if (PyErr_Occurred()) SWIG_fail;
19495 }
19496 resultobj = SWIG_Py_Void();
19497 return resultobj;
19498 fail:
19499 return NULL;
19500 }
19501
19502
19503 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19504 PyObject *resultobj = 0;
19505 wxString *arg1 = 0 ;
19506 bool result;
19507 bool temp1 = false ;
19508 PyObject * obj0 = 0 ;
19509 char * kwnames[] = {
19510 (char *) "name", NULL
19511 };
19512
19513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19514 {
19515 arg1 = wxString_in_helper(obj0);
19516 if (arg1 == NULL) SWIG_fail;
19517 temp1 = true;
19518 }
19519 {
19520 PyThreadState* __tstate = wxPyBeginAllowThreads();
19521 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19522 wxPyEndAllowThreads(__tstate);
19523 if (PyErr_Occurred()) SWIG_fail;
19524 }
19525 {
19526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19527 }
19528 {
19529 if (temp1)
19530 delete arg1;
19531 }
19532 return resultobj;
19533 fail:
19534 {
19535 if (temp1)
19536 delete arg1;
19537 }
19538 return NULL;
19539 }
19540
19541
19542 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19543 PyObject *resultobj = 0;
19544 PyObject *result = 0 ;
19545
19546 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19547 {
19548 PyThreadState* __tstate = wxPyBeginAllowThreads();
19549 result = (PyObject *)wxImage_GetHandlers();
19550 wxPyEndAllowThreads(__tstate);
19551 if (PyErr_Occurred()) SWIG_fail;
19552 }
19553 resultobj = result;
19554 return resultobj;
19555 fail:
19556 return NULL;
19557 }
19558
19559
19560 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19561 PyObject *resultobj = 0;
19562 wxString result;
19563
19564 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19565 {
19566 PyThreadState* __tstate = wxPyBeginAllowThreads();
19567 result = wxImage::GetImageExtWildcard();
19568 wxPyEndAllowThreads(__tstate);
19569 if (PyErr_Occurred()) SWIG_fail;
19570 }
19571 {
19572 #if wxUSE_UNICODE
19573 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19574 #else
19575 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19576 #endif
19577 }
19578 return resultobj;
19579 fail:
19580 return NULL;
19581 }
19582
19583
19584 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19585 PyObject *resultobj = 0;
19586 wxImage *arg1 = (wxImage *) 0 ;
19587 int arg2 = (int) -1 ;
19588 wxBitmap result;
19589 void *argp1 = 0 ;
19590 int res1 = 0 ;
19591 int val2 ;
19592 int ecode2 = 0 ;
19593 PyObject * obj0 = 0 ;
19594 PyObject * obj1 = 0 ;
19595 char * kwnames[] = {
19596 (char *) "self",(char *) "depth", NULL
19597 };
19598
19599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19601 if (!SWIG_IsOK(res1)) {
19602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19603 }
19604 arg1 = reinterpret_cast< wxImage * >(argp1);
19605 if (obj1) {
19606 ecode2 = SWIG_AsVal_int(obj1, &val2);
19607 if (!SWIG_IsOK(ecode2)) {
19608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19609 }
19610 arg2 = static_cast< int >(val2);
19611 }
19612 {
19613 if (!wxPyCheckForApp()) SWIG_fail;
19614 PyThreadState* __tstate = wxPyBeginAllowThreads();
19615 result = wxImage_ConvertToBitmap(arg1,arg2);
19616 wxPyEndAllowThreads(__tstate);
19617 if (PyErr_Occurred()) SWIG_fail;
19618 }
19619 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19620 return resultobj;
19621 fail:
19622 return NULL;
19623 }
19624
19625
19626 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19627 PyObject *resultobj = 0;
19628 wxImage *arg1 = (wxImage *) 0 ;
19629 byte arg2 ;
19630 byte arg3 ;
19631 byte arg4 ;
19632 wxBitmap result;
19633 void *argp1 = 0 ;
19634 int res1 = 0 ;
19635 unsigned char val2 ;
19636 int ecode2 = 0 ;
19637 unsigned char val3 ;
19638 int ecode3 = 0 ;
19639 unsigned char val4 ;
19640 int ecode4 = 0 ;
19641 PyObject * obj0 = 0 ;
19642 PyObject * obj1 = 0 ;
19643 PyObject * obj2 = 0 ;
19644 PyObject * obj3 = 0 ;
19645 char * kwnames[] = {
19646 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19647 };
19648
19649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19651 if (!SWIG_IsOK(res1)) {
19652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19653 }
19654 arg1 = reinterpret_cast< wxImage * >(argp1);
19655 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19656 if (!SWIG_IsOK(ecode2)) {
19657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19658 }
19659 arg2 = static_cast< byte >(val2);
19660 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19661 if (!SWIG_IsOK(ecode3)) {
19662 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19663 }
19664 arg3 = static_cast< byte >(val3);
19665 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19666 if (!SWIG_IsOK(ecode4)) {
19667 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19668 }
19669 arg4 = static_cast< byte >(val4);
19670 {
19671 if (!wxPyCheckForApp()) SWIG_fail;
19672 PyThreadState* __tstate = wxPyBeginAllowThreads();
19673 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19674 wxPyEndAllowThreads(__tstate);
19675 if (PyErr_Occurred()) SWIG_fail;
19676 }
19677 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19678 return resultobj;
19679 fail:
19680 return NULL;
19681 }
19682
19683
19684 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19685 PyObject *resultobj = 0;
19686 wxImage *arg1 = (wxImage *) 0 ;
19687 double arg2 ;
19688 void *argp1 = 0 ;
19689 int res1 = 0 ;
19690 double val2 ;
19691 int ecode2 = 0 ;
19692 PyObject * obj0 = 0 ;
19693 PyObject * obj1 = 0 ;
19694 char * kwnames[] = {
19695 (char *) "self",(char *) "angle", NULL
19696 };
19697
19698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19700 if (!SWIG_IsOK(res1)) {
19701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19702 }
19703 arg1 = reinterpret_cast< wxImage * >(argp1);
19704 ecode2 = SWIG_AsVal_double(obj1, &val2);
19705 if (!SWIG_IsOK(ecode2)) {
19706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19707 }
19708 arg2 = static_cast< double >(val2);
19709 {
19710 PyThreadState* __tstate = wxPyBeginAllowThreads();
19711 (arg1)->RotateHue(arg2);
19712 wxPyEndAllowThreads(__tstate);
19713 if (PyErr_Occurred()) SWIG_fail;
19714 }
19715 resultobj = SWIG_Py_Void();
19716 return resultobj;
19717 fail:
19718 return NULL;
19719 }
19720
19721
19722 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19723 PyObject *resultobj = 0;
19724 wxImage_RGBValue arg1 ;
19725 wxImage_HSVValue result;
19726 void *argp1 ;
19727 int res1 = 0 ;
19728 PyObject * obj0 = 0 ;
19729 char * kwnames[] = {
19730 (char *) "rgb", NULL
19731 };
19732
19733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19734 {
19735 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19736 if (!SWIG_IsOK(res1)) {
19737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19738 }
19739 if (!argp1) {
19740 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19741 } else {
19742 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19743 arg1 = *temp;
19744 if (SWIG_IsNewObj(res1)) delete temp;
19745 }
19746 }
19747 {
19748 PyThreadState* __tstate = wxPyBeginAllowThreads();
19749 result = wxImage::RGBtoHSV(arg1);
19750 wxPyEndAllowThreads(__tstate);
19751 if (PyErr_Occurred()) SWIG_fail;
19752 }
19753 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19754 return resultobj;
19755 fail:
19756 return NULL;
19757 }
19758
19759
19760 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19761 PyObject *resultobj = 0;
19762 wxImage_HSVValue arg1 ;
19763 wxImage_RGBValue result;
19764 void *argp1 ;
19765 int res1 = 0 ;
19766 PyObject * obj0 = 0 ;
19767 char * kwnames[] = {
19768 (char *) "hsv", NULL
19769 };
19770
19771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19772 {
19773 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19774 if (!SWIG_IsOK(res1)) {
19775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19776 }
19777 if (!argp1) {
19778 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19779 } else {
19780 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19781 arg1 = *temp;
19782 if (SWIG_IsNewObj(res1)) delete temp;
19783 }
19784 }
19785 {
19786 PyThreadState* __tstate = wxPyBeginAllowThreads();
19787 result = wxImage::HSVtoRGB(arg1);
19788 wxPyEndAllowThreads(__tstate);
19789 if (PyErr_Occurred()) SWIG_fail;
19790 }
19791 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19792 return resultobj;
19793 fail:
19794 return NULL;
19795 }
19796
19797
19798 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19799 PyObject *obj;
19800 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19801 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19802 return SWIG_Py_Void();
19803 }
19804
19805 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19806 return SWIG_Python_InitShadowInstance(args);
19807 }
19808
19809 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19810 PyObject *resultobj = 0;
19811 int arg1 ;
19812 int arg2 ;
19813 buffer arg3 ;
19814 int arg4 ;
19815 buffer arg5 = (buffer) NULL ;
19816 int arg6 = (int) 0 ;
19817 wxImage *result = 0 ;
19818 int val1 ;
19819 int ecode1 = 0 ;
19820 int val2 ;
19821 int ecode2 = 0 ;
19822 Py_ssize_t temp3 ;
19823 Py_ssize_t temp5 ;
19824 PyObject * obj0 = 0 ;
19825 PyObject * obj1 = 0 ;
19826 PyObject * obj2 = 0 ;
19827 PyObject * obj3 = 0 ;
19828 char * kwnames[] = {
19829 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19830 };
19831
19832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19833 ecode1 = SWIG_AsVal_int(obj0, &val1);
19834 if (!SWIG_IsOK(ecode1)) {
19835 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19836 }
19837 arg1 = static_cast< int >(val1);
19838 ecode2 = SWIG_AsVal_int(obj1, &val2);
19839 if (!SWIG_IsOK(ecode2)) {
19840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19841 }
19842 arg2 = static_cast< int >(val2);
19843 {
19844 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19845 arg4 = (int)temp3;
19846 }
19847 if (obj3) {
19848 {
19849 if (obj3 != Py_None) {
19850 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19851 arg6 = (int)temp5;
19852 }
19853 }
19854 }
19855 {
19856 PyThreadState* __tstate = wxPyBeginAllowThreads();
19857 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19858 wxPyEndAllowThreads(__tstate);
19859 if (PyErr_Occurred()) SWIG_fail;
19860 }
19861 {
19862 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19863 }
19864 return resultobj;
19865 fail:
19866 return NULL;
19867 }
19868
19869
19870 SWIGINTERN int NullImage_set(PyObject *) {
19871 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19872 return 1;
19873 }
19874
19875
19876 SWIGINTERN PyObject *NullImage_get(void) {
19877 PyObject *pyobj = 0;
19878
19879 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19880 return pyobj;
19881 }
19882
19883
19884 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19885 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19886 return 1;
19887 }
19888
19889
19890 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19891 PyObject *pyobj = 0;
19892
19893 {
19894 #if wxUSE_UNICODE
19895 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19896 #else
19897 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19898 #endif
19899 }
19900 return pyobj;
19901 }
19902
19903
19904 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19905 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19906 return 1;
19907 }
19908
19909
19910 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19911 PyObject *pyobj = 0;
19912
19913 {
19914 #if wxUSE_UNICODE
19915 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19916 #else
19917 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19918 #endif
19919 }
19920 return pyobj;
19921 }
19922
19923
19924 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19925 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19926 return 1;
19927 }
19928
19929
19930 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19931 PyObject *pyobj = 0;
19932
19933 {
19934 #if wxUSE_UNICODE
19935 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19936 #else
19937 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19938 #endif
19939 }
19940 return pyobj;
19941 }
19942
19943
19944 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19945 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19946 return 1;
19947 }
19948
19949
19950 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19951 PyObject *pyobj = 0;
19952
19953 {
19954 #if wxUSE_UNICODE
19955 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19956 #else
19957 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19958 #endif
19959 }
19960 return pyobj;
19961 }
19962
19963
19964 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19965 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19966 return 1;
19967 }
19968
19969
19970 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19971 PyObject *pyobj = 0;
19972
19973 {
19974 #if wxUSE_UNICODE
19975 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19976 #else
19977 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19978 #endif
19979 }
19980 return pyobj;
19981 }
19982
19983
19984 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
19985 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
19986 return 1;
19987 }
19988
19989
19990 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
19991 PyObject *pyobj = 0;
19992
19993 {
19994 #if wxUSE_UNICODE
19995 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19996 #else
19997 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19998 #endif
19999 }
20000 return pyobj;
20001 }
20002
20003
20004 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
20005 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
20006 return 1;
20007 }
20008
20009
20010 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
20011 PyObject *pyobj = 0;
20012
20013 {
20014 #if wxUSE_UNICODE
20015 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
20016 #else
20017 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
20018 #endif
20019 }
20020 return pyobj;
20021 }
20022
20023
20024 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
20025 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
20026 return 1;
20027 }
20028
20029
20030 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
20031 PyObject *pyobj = 0;
20032
20033 {
20034 #if wxUSE_UNICODE
20035 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
20036 #else
20037 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
20038 #endif
20039 }
20040 return pyobj;
20041 }
20042
20043
20044 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
20045 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
20046 return 1;
20047 }
20048
20049
20050 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
20051 PyObject *pyobj = 0;
20052
20053 {
20054 #if wxUSE_UNICODE
20055 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20056 #else
20057 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20058 #endif
20059 }
20060 return pyobj;
20061 }
20062
20063
20064 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
20065 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
20066 return 1;
20067 }
20068
20069
20070 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20071 PyObject *pyobj = 0;
20072
20073 {
20074 #if wxUSE_UNICODE
20075 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20076 #else
20077 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20078 #endif
20079 }
20080 return pyobj;
20081 }
20082
20083
20084 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20085 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20086 return 1;
20087 }
20088
20089
20090 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20091 PyObject *pyobj = 0;
20092
20093 {
20094 #if wxUSE_UNICODE
20095 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20096 #else
20097 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20098 #endif
20099 }
20100 return pyobj;
20101 }
20102
20103
20104 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20105 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20106 return 1;
20107 }
20108
20109
20110 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20111 PyObject *pyobj = 0;
20112
20113 {
20114 #if wxUSE_UNICODE
20115 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20116 #else
20117 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20118 #endif
20119 }
20120 return pyobj;
20121 }
20122
20123
20124 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20125 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20126 return 1;
20127 }
20128
20129
20130 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20131 PyObject *pyobj = 0;
20132
20133 {
20134 #if wxUSE_UNICODE
20135 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20136 #else
20137 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20138 #endif
20139 }
20140 return pyobj;
20141 }
20142
20143
20144 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20145 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20146 return 1;
20147 }
20148
20149
20150 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20151 PyObject *pyobj = 0;
20152
20153 {
20154 #if wxUSE_UNICODE
20155 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20156 #else
20157 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20158 #endif
20159 }
20160 return pyobj;
20161 }
20162
20163
20164 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20165 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20166 return 1;
20167 }
20168
20169
20170 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20171 PyObject *pyobj = 0;
20172
20173 {
20174 #if wxUSE_UNICODE
20175 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20176 #else
20177 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20178 #endif
20179 }
20180 return pyobj;
20181 }
20182
20183
20184 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20185 PyObject *resultobj = 0;
20186 wxBMPHandler *result = 0 ;
20187
20188 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20189 {
20190 PyThreadState* __tstate = wxPyBeginAllowThreads();
20191 result = (wxBMPHandler *)new wxBMPHandler();
20192 wxPyEndAllowThreads(__tstate);
20193 if (PyErr_Occurred()) SWIG_fail;
20194 }
20195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20196 return resultobj;
20197 fail:
20198 return NULL;
20199 }
20200
20201
20202 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20203 PyObject *obj;
20204 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20205 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20206 return SWIG_Py_Void();
20207 }
20208
20209 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20210 return SWIG_Python_InitShadowInstance(args);
20211 }
20212
20213 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20214 PyObject *resultobj = 0;
20215 wxICOHandler *result = 0 ;
20216
20217 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20218 {
20219 PyThreadState* __tstate = wxPyBeginAllowThreads();
20220 result = (wxICOHandler *)new wxICOHandler();
20221 wxPyEndAllowThreads(__tstate);
20222 if (PyErr_Occurred()) SWIG_fail;
20223 }
20224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20225 return resultobj;
20226 fail:
20227 return NULL;
20228 }
20229
20230
20231 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20232 PyObject *obj;
20233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20234 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20235 return SWIG_Py_Void();
20236 }
20237
20238 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20239 return SWIG_Python_InitShadowInstance(args);
20240 }
20241
20242 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20243 PyObject *resultobj = 0;
20244 wxCURHandler *result = 0 ;
20245
20246 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20247 {
20248 PyThreadState* __tstate = wxPyBeginAllowThreads();
20249 result = (wxCURHandler *)new wxCURHandler();
20250 wxPyEndAllowThreads(__tstate);
20251 if (PyErr_Occurred()) SWIG_fail;
20252 }
20253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20254 return resultobj;
20255 fail:
20256 return NULL;
20257 }
20258
20259
20260 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20261 PyObject *obj;
20262 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20263 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20264 return SWIG_Py_Void();
20265 }
20266
20267 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20268 return SWIG_Python_InitShadowInstance(args);
20269 }
20270
20271 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20272 PyObject *resultobj = 0;
20273 wxANIHandler *result = 0 ;
20274
20275 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20276 {
20277 PyThreadState* __tstate = wxPyBeginAllowThreads();
20278 result = (wxANIHandler *)new wxANIHandler();
20279 wxPyEndAllowThreads(__tstate);
20280 if (PyErr_Occurred()) SWIG_fail;
20281 }
20282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20283 return resultobj;
20284 fail:
20285 return NULL;
20286 }
20287
20288
20289 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20290 PyObject *obj;
20291 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20292 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20293 return SWIG_Py_Void();
20294 }
20295
20296 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20297 return SWIG_Python_InitShadowInstance(args);
20298 }
20299
20300 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20301 PyObject *resultobj = 0;
20302 wxPNGHandler *result = 0 ;
20303
20304 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20305 {
20306 PyThreadState* __tstate = wxPyBeginAllowThreads();
20307 result = (wxPNGHandler *)new wxPNGHandler();
20308 wxPyEndAllowThreads(__tstate);
20309 if (PyErr_Occurred()) SWIG_fail;
20310 }
20311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20312 return resultobj;
20313 fail:
20314 return NULL;
20315 }
20316
20317
20318 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20319 PyObject *obj;
20320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20321 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20322 return SWIG_Py_Void();
20323 }
20324
20325 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20326 return SWIG_Python_InitShadowInstance(args);
20327 }
20328
20329 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20330 PyObject *resultobj = 0;
20331 wxGIFHandler *result = 0 ;
20332
20333 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20334 {
20335 PyThreadState* __tstate = wxPyBeginAllowThreads();
20336 result = (wxGIFHandler *)new wxGIFHandler();
20337 wxPyEndAllowThreads(__tstate);
20338 if (PyErr_Occurred()) SWIG_fail;
20339 }
20340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20341 return resultobj;
20342 fail:
20343 return NULL;
20344 }
20345
20346
20347 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20348 PyObject *obj;
20349 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20350 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20351 return SWIG_Py_Void();
20352 }
20353
20354 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20355 return SWIG_Python_InitShadowInstance(args);
20356 }
20357
20358 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20359 PyObject *resultobj = 0;
20360 wxPCXHandler *result = 0 ;
20361
20362 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20363 {
20364 PyThreadState* __tstate = wxPyBeginAllowThreads();
20365 result = (wxPCXHandler *)new wxPCXHandler();
20366 wxPyEndAllowThreads(__tstate);
20367 if (PyErr_Occurred()) SWIG_fail;
20368 }
20369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20370 return resultobj;
20371 fail:
20372 return NULL;
20373 }
20374
20375
20376 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20377 PyObject *obj;
20378 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20379 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20380 return SWIG_Py_Void();
20381 }
20382
20383 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20384 return SWIG_Python_InitShadowInstance(args);
20385 }
20386
20387 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20388 PyObject *resultobj = 0;
20389 wxJPEGHandler *result = 0 ;
20390
20391 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20392 {
20393 PyThreadState* __tstate = wxPyBeginAllowThreads();
20394 result = (wxJPEGHandler *)new wxJPEGHandler();
20395 wxPyEndAllowThreads(__tstate);
20396 if (PyErr_Occurred()) SWIG_fail;
20397 }
20398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20399 return resultobj;
20400 fail:
20401 return NULL;
20402 }
20403
20404
20405 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20406 PyObject *obj;
20407 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20408 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20409 return SWIG_Py_Void();
20410 }
20411
20412 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20413 return SWIG_Python_InitShadowInstance(args);
20414 }
20415
20416 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20417 PyObject *resultobj = 0;
20418 wxPNMHandler *result = 0 ;
20419
20420 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20421 {
20422 PyThreadState* __tstate = wxPyBeginAllowThreads();
20423 result = (wxPNMHandler *)new wxPNMHandler();
20424 wxPyEndAllowThreads(__tstate);
20425 if (PyErr_Occurred()) SWIG_fail;
20426 }
20427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20428 return resultobj;
20429 fail:
20430 return NULL;
20431 }
20432
20433
20434 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20435 PyObject *obj;
20436 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20437 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20438 return SWIG_Py_Void();
20439 }
20440
20441 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20442 return SWIG_Python_InitShadowInstance(args);
20443 }
20444
20445 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20446 PyObject *resultobj = 0;
20447 wxXPMHandler *result = 0 ;
20448
20449 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20450 {
20451 PyThreadState* __tstate = wxPyBeginAllowThreads();
20452 result = (wxXPMHandler *)new wxXPMHandler();
20453 wxPyEndAllowThreads(__tstate);
20454 if (PyErr_Occurred()) SWIG_fail;
20455 }
20456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20457 return resultobj;
20458 fail:
20459 return NULL;
20460 }
20461
20462
20463 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20464 PyObject *obj;
20465 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20466 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20467 return SWIG_Py_Void();
20468 }
20469
20470 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20471 return SWIG_Python_InitShadowInstance(args);
20472 }
20473
20474 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20475 PyObject *resultobj = 0;
20476 wxTIFFHandler *result = 0 ;
20477
20478 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20479 {
20480 PyThreadState* __tstate = wxPyBeginAllowThreads();
20481 result = (wxTIFFHandler *)new wxTIFFHandler();
20482 wxPyEndAllowThreads(__tstate);
20483 if (PyErr_Occurred()) SWIG_fail;
20484 }
20485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20486 return resultobj;
20487 fail:
20488 return NULL;
20489 }
20490
20491
20492 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20493 PyObject *obj;
20494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20495 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20496 return SWIG_Py_Void();
20497 }
20498
20499 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20500 return SWIG_Python_InitShadowInstance(args);
20501 }
20502
20503 SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20504 PyObject *resultobj = 0;
20505 wxTGAHandler *result = 0 ;
20506
20507 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
20508 {
20509 PyThreadState* __tstate = wxPyBeginAllowThreads();
20510 result = (wxTGAHandler *)new wxTGAHandler();
20511 wxPyEndAllowThreads(__tstate);
20512 if (PyErr_Occurred()) SWIG_fail;
20513 }
20514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
20515 return resultobj;
20516 fail:
20517 return NULL;
20518 }
20519
20520
20521 SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20522 PyObject *obj;
20523 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20524 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
20525 return SWIG_Py_Void();
20526 }
20527
20528 SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20529 return SWIG_Python_InitShadowInstance(args);
20530 }
20531
20532 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20533 PyObject *resultobj = 0;
20534 wxImage *arg1 = 0 ;
20535 wxImage *arg2 = 0 ;
20536 int arg3 = (int) 236 ;
20537 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20538 bool result;
20539 void *argp1 = 0 ;
20540 int res1 = 0 ;
20541 void *argp2 = 0 ;
20542 int res2 = 0 ;
20543 int val3 ;
20544 int ecode3 = 0 ;
20545 int val4 ;
20546 int ecode4 = 0 ;
20547 PyObject * obj0 = 0 ;
20548 PyObject * obj1 = 0 ;
20549 PyObject * obj2 = 0 ;
20550 PyObject * obj3 = 0 ;
20551 char * kwnames[] = {
20552 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20553 };
20554
20555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20556 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20557 if (!SWIG_IsOK(res1)) {
20558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20559 }
20560 if (!argp1) {
20561 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20562 }
20563 arg1 = reinterpret_cast< wxImage * >(argp1);
20564 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20565 if (!SWIG_IsOK(res2)) {
20566 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20567 }
20568 if (!argp2) {
20569 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20570 }
20571 arg2 = reinterpret_cast< wxImage * >(argp2);
20572 if (obj2) {
20573 ecode3 = SWIG_AsVal_int(obj2, &val3);
20574 if (!SWIG_IsOK(ecode3)) {
20575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20576 }
20577 arg3 = static_cast< int >(val3);
20578 }
20579 if (obj3) {
20580 ecode4 = SWIG_AsVal_int(obj3, &val4);
20581 if (!SWIG_IsOK(ecode4)) {
20582 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20583 }
20584 arg4 = static_cast< int >(val4);
20585 }
20586 {
20587 PyThreadState* __tstate = wxPyBeginAllowThreads();
20588 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20589 wxPyEndAllowThreads(__tstate);
20590 if (PyErr_Occurred()) SWIG_fail;
20591 }
20592 {
20593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20594 }
20595 return resultobj;
20596 fail:
20597 return NULL;
20598 }
20599
20600
20601 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20602 PyObject *obj;
20603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20604 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20605 return SWIG_Py_Void();
20606 }
20607
20608 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20609 PyObject *resultobj = 0;
20610 wxEvtHandler *result = 0 ;
20611
20612 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20613 {
20614 PyThreadState* __tstate = wxPyBeginAllowThreads();
20615 result = (wxEvtHandler *)new wxEvtHandler();
20616 wxPyEndAllowThreads(__tstate);
20617 if (PyErr_Occurred()) SWIG_fail;
20618 }
20619 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20620 return resultobj;
20621 fail:
20622 return NULL;
20623 }
20624
20625
20626 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20627 PyObject *resultobj = 0;
20628 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20629 wxEvtHandler *result = 0 ;
20630 void *argp1 = 0 ;
20631 int res1 = 0 ;
20632 PyObject *swig_obj[1] ;
20633
20634 if (!args) SWIG_fail;
20635 swig_obj[0] = args;
20636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20637 if (!SWIG_IsOK(res1)) {
20638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20639 }
20640 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20641 {
20642 PyThreadState* __tstate = wxPyBeginAllowThreads();
20643 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20644 wxPyEndAllowThreads(__tstate);
20645 if (PyErr_Occurred()) SWIG_fail;
20646 }
20647 {
20648 resultobj = wxPyMake_wxObject(result, 0);
20649 }
20650 return resultobj;
20651 fail:
20652 return NULL;
20653 }
20654
20655
20656 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20657 PyObject *resultobj = 0;
20658 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20659 wxEvtHandler *result = 0 ;
20660 void *argp1 = 0 ;
20661 int res1 = 0 ;
20662 PyObject *swig_obj[1] ;
20663
20664 if (!args) SWIG_fail;
20665 swig_obj[0] = args;
20666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20667 if (!SWIG_IsOK(res1)) {
20668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20669 }
20670 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20671 {
20672 PyThreadState* __tstate = wxPyBeginAllowThreads();
20673 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20674 wxPyEndAllowThreads(__tstate);
20675 if (PyErr_Occurred()) SWIG_fail;
20676 }
20677 {
20678 resultobj = wxPyMake_wxObject(result, 0);
20679 }
20680 return resultobj;
20681 fail:
20682 return NULL;
20683 }
20684
20685
20686 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20687 PyObject *resultobj = 0;
20688 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20689 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20690 void *argp1 = 0 ;
20691 int res1 = 0 ;
20692 void *argp2 = 0 ;
20693 int res2 = 0 ;
20694 PyObject * obj0 = 0 ;
20695 PyObject * obj1 = 0 ;
20696 char * kwnames[] = {
20697 (char *) "self",(char *) "handler", NULL
20698 };
20699
20700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20702 if (!SWIG_IsOK(res1)) {
20703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20704 }
20705 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20706 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20707 if (!SWIG_IsOK(res2)) {
20708 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20709 }
20710 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20711 {
20712 PyThreadState* __tstate = wxPyBeginAllowThreads();
20713 (arg1)->SetNextHandler(arg2);
20714 wxPyEndAllowThreads(__tstate);
20715 if (PyErr_Occurred()) SWIG_fail;
20716 }
20717 resultobj = SWIG_Py_Void();
20718 return resultobj;
20719 fail:
20720 return NULL;
20721 }
20722
20723
20724 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20725 PyObject *resultobj = 0;
20726 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20727 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20728 void *argp1 = 0 ;
20729 int res1 = 0 ;
20730 void *argp2 = 0 ;
20731 int res2 = 0 ;
20732 PyObject * obj0 = 0 ;
20733 PyObject * obj1 = 0 ;
20734 char * kwnames[] = {
20735 (char *) "self",(char *) "handler", NULL
20736 };
20737
20738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20740 if (!SWIG_IsOK(res1)) {
20741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20742 }
20743 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20744 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20745 if (!SWIG_IsOK(res2)) {
20746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20747 }
20748 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20749 {
20750 PyThreadState* __tstate = wxPyBeginAllowThreads();
20751 (arg1)->SetPreviousHandler(arg2);
20752 wxPyEndAllowThreads(__tstate);
20753 if (PyErr_Occurred()) SWIG_fail;
20754 }
20755 resultobj = SWIG_Py_Void();
20756 return resultobj;
20757 fail:
20758 return NULL;
20759 }
20760
20761
20762 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20763 PyObject *resultobj = 0;
20764 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20765 bool result;
20766 void *argp1 = 0 ;
20767 int res1 = 0 ;
20768 PyObject *swig_obj[1] ;
20769
20770 if (!args) SWIG_fail;
20771 swig_obj[0] = args;
20772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20773 if (!SWIG_IsOK(res1)) {
20774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20775 }
20776 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20777 {
20778 PyThreadState* __tstate = wxPyBeginAllowThreads();
20779 result = (bool)(arg1)->GetEvtHandlerEnabled();
20780 wxPyEndAllowThreads(__tstate);
20781 if (PyErr_Occurred()) SWIG_fail;
20782 }
20783 {
20784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20785 }
20786 return resultobj;
20787 fail:
20788 return NULL;
20789 }
20790
20791
20792 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20793 PyObject *resultobj = 0;
20794 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20795 bool arg2 ;
20796 void *argp1 = 0 ;
20797 int res1 = 0 ;
20798 bool val2 ;
20799 int ecode2 = 0 ;
20800 PyObject * obj0 = 0 ;
20801 PyObject * obj1 = 0 ;
20802 char * kwnames[] = {
20803 (char *) "self",(char *) "enabled", NULL
20804 };
20805
20806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20808 if (!SWIG_IsOK(res1)) {
20809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20810 }
20811 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20812 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20813 if (!SWIG_IsOK(ecode2)) {
20814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20815 }
20816 arg2 = static_cast< bool >(val2);
20817 {
20818 PyThreadState* __tstate = wxPyBeginAllowThreads();
20819 (arg1)->SetEvtHandlerEnabled(arg2);
20820 wxPyEndAllowThreads(__tstate);
20821 if (PyErr_Occurred()) SWIG_fail;
20822 }
20823 resultobj = SWIG_Py_Void();
20824 return resultobj;
20825 fail:
20826 return NULL;
20827 }
20828
20829
20830 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20831 PyObject *resultobj = 0;
20832 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20833 wxEvent *arg2 = 0 ;
20834 bool result;
20835 void *argp1 = 0 ;
20836 int res1 = 0 ;
20837 void *argp2 = 0 ;
20838 int res2 = 0 ;
20839 PyObject * obj0 = 0 ;
20840 PyObject * obj1 = 0 ;
20841 char * kwnames[] = {
20842 (char *) "self",(char *) "event", NULL
20843 };
20844
20845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20847 if (!SWIG_IsOK(res1)) {
20848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20849 }
20850 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20851 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20852 if (!SWIG_IsOK(res2)) {
20853 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20854 }
20855 if (!argp2) {
20856 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20857 }
20858 arg2 = reinterpret_cast< wxEvent * >(argp2);
20859 {
20860 PyThreadState* __tstate = wxPyBeginAllowThreads();
20861 result = (bool)(arg1)->ProcessEvent(*arg2);
20862 wxPyEndAllowThreads(__tstate);
20863 if (PyErr_Occurred()) SWIG_fail;
20864 }
20865 {
20866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20867 }
20868 return resultobj;
20869 fail:
20870 return NULL;
20871 }
20872
20873
20874 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20875 PyObject *resultobj = 0;
20876 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20877 wxEvent *arg2 = 0 ;
20878 void *argp1 = 0 ;
20879 int res1 = 0 ;
20880 void *argp2 = 0 ;
20881 int res2 = 0 ;
20882 PyObject * obj0 = 0 ;
20883 PyObject * obj1 = 0 ;
20884 char * kwnames[] = {
20885 (char *) "self",(char *) "event", NULL
20886 };
20887
20888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20890 if (!SWIG_IsOK(res1)) {
20891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20892 }
20893 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20894 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20895 if (!SWIG_IsOK(res2)) {
20896 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20897 }
20898 if (!argp2) {
20899 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20900 }
20901 arg2 = reinterpret_cast< wxEvent * >(argp2);
20902 {
20903 PyThreadState* __tstate = wxPyBeginAllowThreads();
20904 (arg1)->AddPendingEvent(*arg2);
20905 wxPyEndAllowThreads(__tstate);
20906 if (PyErr_Occurred()) SWIG_fail;
20907 }
20908 resultobj = SWIG_Py_Void();
20909 return resultobj;
20910 fail:
20911 return NULL;
20912 }
20913
20914
20915 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20916 PyObject *resultobj = 0;
20917 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20918 void *argp1 = 0 ;
20919 int res1 = 0 ;
20920 PyObject *swig_obj[1] ;
20921
20922 if (!args) SWIG_fail;
20923 swig_obj[0] = args;
20924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20925 if (!SWIG_IsOK(res1)) {
20926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20927 }
20928 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20929 {
20930 PyThreadState* __tstate = wxPyBeginAllowThreads();
20931 (arg1)->ProcessPendingEvents();
20932 wxPyEndAllowThreads(__tstate);
20933 if (PyErr_Occurred()) SWIG_fail;
20934 }
20935 resultobj = SWIG_Py_Void();
20936 return resultobj;
20937 fail:
20938 return NULL;
20939 }
20940
20941
20942 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20943 PyObject *resultobj = 0;
20944 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20945 int arg2 ;
20946 int arg3 ;
20947 int arg4 ;
20948 PyObject *arg5 = (PyObject *) 0 ;
20949 void *argp1 = 0 ;
20950 int res1 = 0 ;
20951 int val2 ;
20952 int ecode2 = 0 ;
20953 int val3 ;
20954 int ecode3 = 0 ;
20955 int val4 ;
20956 int ecode4 = 0 ;
20957 PyObject * obj0 = 0 ;
20958 PyObject * obj1 = 0 ;
20959 PyObject * obj2 = 0 ;
20960 PyObject * obj3 = 0 ;
20961 PyObject * obj4 = 0 ;
20962 char * kwnames[] = {
20963 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20964 };
20965
20966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20968 if (!SWIG_IsOK(res1)) {
20969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20970 }
20971 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20972 ecode2 = SWIG_AsVal_int(obj1, &val2);
20973 if (!SWIG_IsOK(ecode2)) {
20974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
20975 }
20976 arg2 = static_cast< int >(val2);
20977 ecode3 = SWIG_AsVal_int(obj2, &val3);
20978 if (!SWIG_IsOK(ecode3)) {
20979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
20980 }
20981 arg3 = static_cast< int >(val3);
20982 ecode4 = SWIG_AsVal_int(obj3, &val4);
20983 if (!SWIG_IsOK(ecode4)) {
20984 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
20985 }
20986 arg4 = static_cast< int >(val4);
20987 arg5 = obj4;
20988 {
20989 PyThreadState* __tstate = wxPyBeginAllowThreads();
20990 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
20991 wxPyEndAllowThreads(__tstate);
20992 if (PyErr_Occurred()) SWIG_fail;
20993 }
20994 resultobj = SWIG_Py_Void();
20995 return resultobj;
20996 fail:
20997 return NULL;
20998 }
20999
21000
21001 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21002 PyObject *resultobj = 0;
21003 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21004 int arg2 ;
21005 int arg3 = (int) -1 ;
21006 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
21007 bool result;
21008 void *argp1 = 0 ;
21009 int res1 = 0 ;
21010 int val2 ;
21011 int ecode2 = 0 ;
21012 int val3 ;
21013 int ecode3 = 0 ;
21014 int val4 ;
21015 int ecode4 = 0 ;
21016 PyObject * obj0 = 0 ;
21017 PyObject * obj1 = 0 ;
21018 PyObject * obj2 = 0 ;
21019 PyObject * obj3 = 0 ;
21020 char * kwnames[] = {
21021 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
21022 };
21023
21024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21026 if (!SWIG_IsOK(res1)) {
21027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21028 }
21029 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21030 ecode2 = SWIG_AsVal_int(obj1, &val2);
21031 if (!SWIG_IsOK(ecode2)) {
21032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
21033 }
21034 arg2 = static_cast< int >(val2);
21035 if (obj2) {
21036 ecode3 = SWIG_AsVal_int(obj2, &val3);
21037 if (!SWIG_IsOK(ecode3)) {
21038 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
21039 }
21040 arg3 = static_cast< int >(val3);
21041 }
21042 if (obj3) {
21043 ecode4 = SWIG_AsVal_int(obj3, &val4);
21044 if (!SWIG_IsOK(ecode4)) {
21045 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
21046 }
21047 arg4 = static_cast< wxEventType >(val4);
21048 }
21049 {
21050 PyThreadState* __tstate = wxPyBeginAllowThreads();
21051 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
21052 wxPyEndAllowThreads(__tstate);
21053 if (PyErr_Occurred()) SWIG_fail;
21054 }
21055 {
21056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21057 }
21058 return resultobj;
21059 fail:
21060 return NULL;
21061 }
21062
21063
21064 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21065 PyObject *resultobj = 0;
21066 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21067 PyObject *arg2 = (PyObject *) 0 ;
21068 bool arg3 = (bool) true ;
21069 void *argp1 = 0 ;
21070 int res1 = 0 ;
21071 bool val3 ;
21072 int ecode3 = 0 ;
21073 PyObject * obj0 = 0 ;
21074 PyObject * obj1 = 0 ;
21075 PyObject * obj2 = 0 ;
21076 char * kwnames[] = {
21077 (char *) "self",(char *) "_self",(char *) "incref", NULL
21078 };
21079
21080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21082 if (!SWIG_IsOK(res1)) {
21083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21084 }
21085 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21086 arg2 = obj1;
21087 if (obj2) {
21088 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21089 if (!SWIG_IsOK(ecode3)) {
21090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21091 }
21092 arg3 = static_cast< bool >(val3);
21093 }
21094 {
21095 PyThreadState* __tstate = wxPyBeginAllowThreads();
21096 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21097 wxPyEndAllowThreads(__tstate);
21098 if (PyErr_Occurred()) SWIG_fail;
21099 }
21100 resultobj = SWIG_Py_Void();
21101 return resultobj;
21102 fail:
21103 return NULL;
21104 }
21105
21106
21107 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21108 PyObject *obj;
21109 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21110 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21111 return SWIG_Py_Void();
21112 }
21113
21114 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21115 return SWIG_Python_InitShadowInstance(args);
21116 }
21117
21118 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21119 PyObject *resultobj = 0;
21120 wxEventType result;
21121
21122 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21123 {
21124 PyThreadState* __tstate = wxPyBeginAllowThreads();
21125 result = (wxEventType)wxNewEventType();
21126 wxPyEndAllowThreads(__tstate);
21127 if (PyErr_Occurred()) SWIG_fail;
21128 }
21129 resultobj = SWIG_From_int(static_cast< int >(result));
21130 return resultobj;
21131 fail:
21132 return NULL;
21133 }
21134
21135
21136 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21137 PyObject *resultobj = 0;
21138 wxEvent *arg1 = (wxEvent *) 0 ;
21139 void *argp1 = 0 ;
21140 int res1 = 0 ;
21141 PyObject *swig_obj[1] ;
21142
21143 if (!args) SWIG_fail;
21144 swig_obj[0] = args;
21145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21146 if (!SWIG_IsOK(res1)) {
21147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21148 }
21149 arg1 = reinterpret_cast< wxEvent * >(argp1);
21150 {
21151 PyThreadState* __tstate = wxPyBeginAllowThreads();
21152 delete arg1;
21153
21154 wxPyEndAllowThreads(__tstate);
21155 if (PyErr_Occurred()) SWIG_fail;
21156 }
21157 resultobj = SWIG_Py_Void();
21158 return resultobj;
21159 fail:
21160 return NULL;
21161 }
21162
21163
21164 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21165 PyObject *resultobj = 0;
21166 wxEvent *arg1 = (wxEvent *) 0 ;
21167 wxEventType arg2 ;
21168 void *argp1 = 0 ;
21169 int res1 = 0 ;
21170 int val2 ;
21171 int ecode2 = 0 ;
21172 PyObject * obj0 = 0 ;
21173 PyObject * obj1 = 0 ;
21174 char * kwnames[] = {
21175 (char *) "self",(char *) "typ", NULL
21176 };
21177
21178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21180 if (!SWIG_IsOK(res1)) {
21181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21182 }
21183 arg1 = reinterpret_cast< wxEvent * >(argp1);
21184 ecode2 = SWIG_AsVal_int(obj1, &val2);
21185 if (!SWIG_IsOK(ecode2)) {
21186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21187 }
21188 arg2 = static_cast< wxEventType >(val2);
21189 {
21190 PyThreadState* __tstate = wxPyBeginAllowThreads();
21191 (arg1)->SetEventType(arg2);
21192 wxPyEndAllowThreads(__tstate);
21193 if (PyErr_Occurred()) SWIG_fail;
21194 }
21195 resultobj = SWIG_Py_Void();
21196 return resultobj;
21197 fail:
21198 return NULL;
21199 }
21200
21201
21202 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21203 PyObject *resultobj = 0;
21204 wxEvent *arg1 = (wxEvent *) 0 ;
21205 wxEventType result;
21206 void *argp1 = 0 ;
21207 int res1 = 0 ;
21208 PyObject *swig_obj[1] ;
21209
21210 if (!args) SWIG_fail;
21211 swig_obj[0] = args;
21212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21213 if (!SWIG_IsOK(res1)) {
21214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21215 }
21216 arg1 = reinterpret_cast< wxEvent * >(argp1);
21217 {
21218 PyThreadState* __tstate = wxPyBeginAllowThreads();
21219 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21220 wxPyEndAllowThreads(__tstate);
21221 if (PyErr_Occurred()) SWIG_fail;
21222 }
21223 resultobj = SWIG_From_int(static_cast< int >(result));
21224 return resultobj;
21225 fail:
21226 return NULL;
21227 }
21228
21229
21230 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21231 PyObject *resultobj = 0;
21232 wxEvent *arg1 = (wxEvent *) 0 ;
21233 wxObject *result = 0 ;
21234 void *argp1 = 0 ;
21235 int res1 = 0 ;
21236 PyObject *swig_obj[1] ;
21237
21238 if (!args) SWIG_fail;
21239 swig_obj[0] = args;
21240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21241 if (!SWIG_IsOK(res1)) {
21242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21243 }
21244 arg1 = reinterpret_cast< wxEvent * >(argp1);
21245 {
21246 PyThreadState* __tstate = wxPyBeginAllowThreads();
21247 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21248 wxPyEndAllowThreads(__tstate);
21249 if (PyErr_Occurred()) SWIG_fail;
21250 }
21251 {
21252 resultobj = wxPyMake_wxObject(result, (bool)0);
21253 }
21254 return resultobj;
21255 fail:
21256 return NULL;
21257 }
21258
21259
21260 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21261 PyObject *resultobj = 0;
21262 wxEvent *arg1 = (wxEvent *) 0 ;
21263 wxObject *arg2 = (wxObject *) 0 ;
21264 void *argp1 = 0 ;
21265 int res1 = 0 ;
21266 void *argp2 = 0 ;
21267 int res2 = 0 ;
21268 PyObject * obj0 = 0 ;
21269 PyObject * obj1 = 0 ;
21270 char * kwnames[] = {
21271 (char *) "self",(char *) "obj", NULL
21272 };
21273
21274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21276 if (!SWIG_IsOK(res1)) {
21277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21278 }
21279 arg1 = reinterpret_cast< wxEvent * >(argp1);
21280 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21281 if (!SWIG_IsOK(res2)) {
21282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21283 }
21284 arg2 = reinterpret_cast< wxObject * >(argp2);
21285 {
21286 PyThreadState* __tstate = wxPyBeginAllowThreads();
21287 (arg1)->SetEventObject(arg2);
21288 wxPyEndAllowThreads(__tstate);
21289 if (PyErr_Occurred()) SWIG_fail;
21290 }
21291 resultobj = SWIG_Py_Void();
21292 return resultobj;
21293 fail:
21294 return NULL;
21295 }
21296
21297
21298 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21299 PyObject *resultobj = 0;
21300 wxEvent *arg1 = (wxEvent *) 0 ;
21301 long result;
21302 void *argp1 = 0 ;
21303 int res1 = 0 ;
21304 PyObject *swig_obj[1] ;
21305
21306 if (!args) SWIG_fail;
21307 swig_obj[0] = args;
21308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21309 if (!SWIG_IsOK(res1)) {
21310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21311 }
21312 arg1 = reinterpret_cast< wxEvent * >(argp1);
21313 {
21314 PyThreadState* __tstate = wxPyBeginAllowThreads();
21315 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21316 wxPyEndAllowThreads(__tstate);
21317 if (PyErr_Occurred()) SWIG_fail;
21318 }
21319 resultobj = SWIG_From_long(static_cast< long >(result));
21320 return resultobj;
21321 fail:
21322 return NULL;
21323 }
21324
21325
21326 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21327 PyObject *resultobj = 0;
21328 wxEvent *arg1 = (wxEvent *) 0 ;
21329 long arg2 = (long) 0 ;
21330 void *argp1 = 0 ;
21331 int res1 = 0 ;
21332 long val2 ;
21333 int ecode2 = 0 ;
21334 PyObject * obj0 = 0 ;
21335 PyObject * obj1 = 0 ;
21336 char * kwnames[] = {
21337 (char *) "self",(char *) "ts", NULL
21338 };
21339
21340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21342 if (!SWIG_IsOK(res1)) {
21343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21344 }
21345 arg1 = reinterpret_cast< wxEvent * >(argp1);
21346 if (obj1) {
21347 ecode2 = SWIG_AsVal_long(obj1, &val2);
21348 if (!SWIG_IsOK(ecode2)) {
21349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21350 }
21351 arg2 = static_cast< long >(val2);
21352 }
21353 {
21354 PyThreadState* __tstate = wxPyBeginAllowThreads();
21355 (arg1)->SetTimestamp(arg2);
21356 wxPyEndAllowThreads(__tstate);
21357 if (PyErr_Occurred()) SWIG_fail;
21358 }
21359 resultobj = SWIG_Py_Void();
21360 return resultobj;
21361 fail:
21362 return NULL;
21363 }
21364
21365
21366 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21367 PyObject *resultobj = 0;
21368 wxEvent *arg1 = (wxEvent *) 0 ;
21369 int result;
21370 void *argp1 = 0 ;
21371 int res1 = 0 ;
21372 PyObject *swig_obj[1] ;
21373
21374 if (!args) SWIG_fail;
21375 swig_obj[0] = args;
21376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21377 if (!SWIG_IsOK(res1)) {
21378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21379 }
21380 arg1 = reinterpret_cast< wxEvent * >(argp1);
21381 {
21382 PyThreadState* __tstate = wxPyBeginAllowThreads();
21383 result = (int)((wxEvent const *)arg1)->GetId();
21384 wxPyEndAllowThreads(__tstate);
21385 if (PyErr_Occurred()) SWIG_fail;
21386 }
21387 resultobj = SWIG_From_int(static_cast< int >(result));
21388 return resultobj;
21389 fail:
21390 return NULL;
21391 }
21392
21393
21394 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21395 PyObject *resultobj = 0;
21396 wxEvent *arg1 = (wxEvent *) 0 ;
21397 int arg2 ;
21398 void *argp1 = 0 ;
21399 int res1 = 0 ;
21400 int val2 ;
21401 int ecode2 = 0 ;
21402 PyObject * obj0 = 0 ;
21403 PyObject * obj1 = 0 ;
21404 char * kwnames[] = {
21405 (char *) "self",(char *) "Id", NULL
21406 };
21407
21408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21410 if (!SWIG_IsOK(res1)) {
21411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21412 }
21413 arg1 = reinterpret_cast< wxEvent * >(argp1);
21414 ecode2 = SWIG_AsVal_int(obj1, &val2);
21415 if (!SWIG_IsOK(ecode2)) {
21416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21417 }
21418 arg2 = static_cast< int >(val2);
21419 {
21420 PyThreadState* __tstate = wxPyBeginAllowThreads();
21421 (arg1)->SetId(arg2);
21422 wxPyEndAllowThreads(__tstate);
21423 if (PyErr_Occurred()) SWIG_fail;
21424 }
21425 resultobj = SWIG_Py_Void();
21426 return resultobj;
21427 fail:
21428 return NULL;
21429 }
21430
21431
21432 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21433 PyObject *resultobj = 0;
21434 wxEvent *arg1 = (wxEvent *) 0 ;
21435 bool result;
21436 void *argp1 = 0 ;
21437 int res1 = 0 ;
21438 PyObject *swig_obj[1] ;
21439
21440 if (!args) SWIG_fail;
21441 swig_obj[0] = args;
21442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21443 if (!SWIG_IsOK(res1)) {
21444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21445 }
21446 arg1 = reinterpret_cast< wxEvent * >(argp1);
21447 {
21448 PyThreadState* __tstate = wxPyBeginAllowThreads();
21449 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21450 wxPyEndAllowThreads(__tstate);
21451 if (PyErr_Occurred()) SWIG_fail;
21452 }
21453 {
21454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21455 }
21456 return resultobj;
21457 fail:
21458 return NULL;
21459 }
21460
21461
21462 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21463 PyObject *resultobj = 0;
21464 wxEvent *arg1 = (wxEvent *) 0 ;
21465 bool arg2 = (bool) true ;
21466 void *argp1 = 0 ;
21467 int res1 = 0 ;
21468 bool val2 ;
21469 int ecode2 = 0 ;
21470 PyObject * obj0 = 0 ;
21471 PyObject * obj1 = 0 ;
21472 char * kwnames[] = {
21473 (char *) "self",(char *) "skip", NULL
21474 };
21475
21476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21478 if (!SWIG_IsOK(res1)) {
21479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21480 }
21481 arg1 = reinterpret_cast< wxEvent * >(argp1);
21482 if (obj1) {
21483 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21484 if (!SWIG_IsOK(ecode2)) {
21485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21486 }
21487 arg2 = static_cast< bool >(val2);
21488 }
21489 {
21490 PyThreadState* __tstate = wxPyBeginAllowThreads();
21491 (arg1)->Skip(arg2);
21492 wxPyEndAllowThreads(__tstate);
21493 if (PyErr_Occurred()) SWIG_fail;
21494 }
21495 resultobj = SWIG_Py_Void();
21496 return resultobj;
21497 fail:
21498 return NULL;
21499 }
21500
21501
21502 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21503 PyObject *resultobj = 0;
21504 wxEvent *arg1 = (wxEvent *) 0 ;
21505 bool result;
21506 void *argp1 = 0 ;
21507 int res1 = 0 ;
21508 PyObject *swig_obj[1] ;
21509
21510 if (!args) SWIG_fail;
21511 swig_obj[0] = args;
21512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21513 if (!SWIG_IsOK(res1)) {
21514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21515 }
21516 arg1 = reinterpret_cast< wxEvent * >(argp1);
21517 {
21518 PyThreadState* __tstate = wxPyBeginAllowThreads();
21519 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21520 wxPyEndAllowThreads(__tstate);
21521 if (PyErr_Occurred()) SWIG_fail;
21522 }
21523 {
21524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21525 }
21526 return resultobj;
21527 fail:
21528 return NULL;
21529 }
21530
21531
21532 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21533 PyObject *resultobj = 0;
21534 wxEvent *arg1 = (wxEvent *) 0 ;
21535 bool result;
21536 void *argp1 = 0 ;
21537 int res1 = 0 ;
21538 PyObject *swig_obj[1] ;
21539
21540 if (!args) SWIG_fail;
21541 swig_obj[0] = args;
21542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21543 if (!SWIG_IsOK(res1)) {
21544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21545 }
21546 arg1 = reinterpret_cast< wxEvent * >(argp1);
21547 {
21548 PyThreadState* __tstate = wxPyBeginAllowThreads();
21549 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21550 wxPyEndAllowThreads(__tstate);
21551 if (PyErr_Occurred()) SWIG_fail;
21552 }
21553 {
21554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21555 }
21556 return resultobj;
21557 fail:
21558 return NULL;
21559 }
21560
21561
21562 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21563 PyObject *resultobj = 0;
21564 wxEvent *arg1 = (wxEvent *) 0 ;
21565 int result;
21566 void *argp1 = 0 ;
21567 int res1 = 0 ;
21568 PyObject *swig_obj[1] ;
21569
21570 if (!args) SWIG_fail;
21571 swig_obj[0] = args;
21572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21573 if (!SWIG_IsOK(res1)) {
21574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21575 }
21576 arg1 = reinterpret_cast< wxEvent * >(argp1);
21577 {
21578 PyThreadState* __tstate = wxPyBeginAllowThreads();
21579 result = (int)(arg1)->StopPropagation();
21580 wxPyEndAllowThreads(__tstate);
21581 if (PyErr_Occurred()) SWIG_fail;
21582 }
21583 resultobj = SWIG_From_int(static_cast< int >(result));
21584 return resultobj;
21585 fail:
21586 return NULL;
21587 }
21588
21589
21590 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21591 PyObject *resultobj = 0;
21592 wxEvent *arg1 = (wxEvent *) 0 ;
21593 int arg2 ;
21594 void *argp1 = 0 ;
21595 int res1 = 0 ;
21596 int val2 ;
21597 int ecode2 = 0 ;
21598 PyObject * obj0 = 0 ;
21599 PyObject * obj1 = 0 ;
21600 char * kwnames[] = {
21601 (char *) "self",(char *) "propagationLevel", NULL
21602 };
21603
21604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21606 if (!SWIG_IsOK(res1)) {
21607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21608 }
21609 arg1 = reinterpret_cast< wxEvent * >(argp1);
21610 ecode2 = SWIG_AsVal_int(obj1, &val2);
21611 if (!SWIG_IsOK(ecode2)) {
21612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21613 }
21614 arg2 = static_cast< int >(val2);
21615 {
21616 PyThreadState* __tstate = wxPyBeginAllowThreads();
21617 (arg1)->ResumePropagation(arg2);
21618 wxPyEndAllowThreads(__tstate);
21619 if (PyErr_Occurred()) SWIG_fail;
21620 }
21621 resultobj = SWIG_Py_Void();
21622 return resultobj;
21623 fail:
21624 return NULL;
21625 }
21626
21627
21628 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21629 PyObject *resultobj = 0;
21630 wxEvent *arg1 = (wxEvent *) 0 ;
21631 wxEvent *result = 0 ;
21632 void *argp1 = 0 ;
21633 int res1 = 0 ;
21634 PyObject *swig_obj[1] ;
21635
21636 if (!args) SWIG_fail;
21637 swig_obj[0] = args;
21638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21639 if (!SWIG_IsOK(res1)) {
21640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21641 }
21642 arg1 = reinterpret_cast< wxEvent * >(argp1);
21643 {
21644 PyThreadState* __tstate = wxPyBeginAllowThreads();
21645 result = (wxEvent *)(arg1)->Clone();
21646 wxPyEndAllowThreads(__tstate);
21647 if (PyErr_Occurred()) SWIG_fail;
21648 }
21649 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21650 return resultobj;
21651 fail:
21652 return NULL;
21653 }
21654
21655
21656 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21657 PyObject *obj;
21658 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21659 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21660 return SWIG_Py_Void();
21661 }
21662
21663 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21664 PyObject *resultobj = 0;
21665 wxEvent *arg1 = 0 ;
21666 wxPropagationDisabler *result = 0 ;
21667 void *argp1 = 0 ;
21668 int res1 = 0 ;
21669 PyObject * obj0 = 0 ;
21670 char * kwnames[] = {
21671 (char *) "event", NULL
21672 };
21673
21674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21675 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21676 if (!SWIG_IsOK(res1)) {
21677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21678 }
21679 if (!argp1) {
21680 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21681 }
21682 arg1 = reinterpret_cast< wxEvent * >(argp1);
21683 {
21684 PyThreadState* __tstate = wxPyBeginAllowThreads();
21685 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21686 wxPyEndAllowThreads(__tstate);
21687 if (PyErr_Occurred()) SWIG_fail;
21688 }
21689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21690 return resultobj;
21691 fail:
21692 return NULL;
21693 }
21694
21695
21696 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21697 PyObject *resultobj = 0;
21698 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21699 void *argp1 = 0 ;
21700 int res1 = 0 ;
21701 PyObject *swig_obj[1] ;
21702
21703 if (!args) SWIG_fail;
21704 swig_obj[0] = args;
21705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21706 if (!SWIG_IsOK(res1)) {
21707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21708 }
21709 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21710 {
21711 PyThreadState* __tstate = wxPyBeginAllowThreads();
21712 delete arg1;
21713
21714 wxPyEndAllowThreads(__tstate);
21715 if (PyErr_Occurred()) SWIG_fail;
21716 }
21717 resultobj = SWIG_Py_Void();
21718 return resultobj;
21719 fail:
21720 return NULL;
21721 }
21722
21723
21724 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21725 PyObject *obj;
21726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21727 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21728 return SWIG_Py_Void();
21729 }
21730
21731 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21732 return SWIG_Python_InitShadowInstance(args);
21733 }
21734
21735 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21736 PyObject *resultobj = 0;
21737 wxEvent *arg1 = 0 ;
21738 wxPropagateOnce *result = 0 ;
21739 void *argp1 = 0 ;
21740 int res1 = 0 ;
21741 PyObject * obj0 = 0 ;
21742 char * kwnames[] = {
21743 (char *) "event", NULL
21744 };
21745
21746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21747 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21748 if (!SWIG_IsOK(res1)) {
21749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21750 }
21751 if (!argp1) {
21752 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21753 }
21754 arg1 = reinterpret_cast< wxEvent * >(argp1);
21755 {
21756 PyThreadState* __tstate = wxPyBeginAllowThreads();
21757 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21758 wxPyEndAllowThreads(__tstate);
21759 if (PyErr_Occurred()) SWIG_fail;
21760 }
21761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21762 return resultobj;
21763 fail:
21764 return NULL;
21765 }
21766
21767
21768 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21769 PyObject *resultobj = 0;
21770 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21771 void *argp1 = 0 ;
21772 int res1 = 0 ;
21773 PyObject *swig_obj[1] ;
21774
21775 if (!args) SWIG_fail;
21776 swig_obj[0] = args;
21777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21778 if (!SWIG_IsOK(res1)) {
21779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21780 }
21781 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21782 {
21783 PyThreadState* __tstate = wxPyBeginAllowThreads();
21784 delete arg1;
21785
21786 wxPyEndAllowThreads(__tstate);
21787 if (PyErr_Occurred()) SWIG_fail;
21788 }
21789 resultobj = SWIG_Py_Void();
21790 return resultobj;
21791 fail:
21792 return NULL;
21793 }
21794
21795
21796 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21797 PyObject *obj;
21798 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21799 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21800 return SWIG_Py_Void();
21801 }
21802
21803 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21804 return SWIG_Python_InitShadowInstance(args);
21805 }
21806
21807 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21808 PyObject *resultobj = 0;
21809 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21810 int arg2 = (int) 0 ;
21811 wxCommandEvent *result = 0 ;
21812 int val1 ;
21813 int ecode1 = 0 ;
21814 int val2 ;
21815 int ecode2 = 0 ;
21816 PyObject * obj0 = 0 ;
21817 PyObject * obj1 = 0 ;
21818 char * kwnames[] = {
21819 (char *) "commandType",(char *) "winid", NULL
21820 };
21821
21822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21823 if (obj0) {
21824 ecode1 = SWIG_AsVal_int(obj0, &val1);
21825 if (!SWIG_IsOK(ecode1)) {
21826 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21827 }
21828 arg1 = static_cast< wxEventType >(val1);
21829 }
21830 if (obj1) {
21831 ecode2 = SWIG_AsVal_int(obj1, &val2);
21832 if (!SWIG_IsOK(ecode2)) {
21833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21834 }
21835 arg2 = static_cast< int >(val2);
21836 }
21837 {
21838 PyThreadState* __tstate = wxPyBeginAllowThreads();
21839 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21840 wxPyEndAllowThreads(__tstate);
21841 if (PyErr_Occurred()) SWIG_fail;
21842 }
21843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21844 return resultobj;
21845 fail:
21846 return NULL;
21847 }
21848
21849
21850 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21851 PyObject *resultobj = 0;
21852 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21853 int result;
21854 void *argp1 = 0 ;
21855 int res1 = 0 ;
21856 PyObject *swig_obj[1] ;
21857
21858 if (!args) SWIG_fail;
21859 swig_obj[0] = args;
21860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21861 if (!SWIG_IsOK(res1)) {
21862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21863 }
21864 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21865 {
21866 PyThreadState* __tstate = wxPyBeginAllowThreads();
21867 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21868 wxPyEndAllowThreads(__tstate);
21869 if (PyErr_Occurred()) SWIG_fail;
21870 }
21871 resultobj = SWIG_From_int(static_cast< int >(result));
21872 return resultobj;
21873 fail:
21874 return NULL;
21875 }
21876
21877
21878 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21879 PyObject *resultobj = 0;
21880 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21881 wxString *arg2 = 0 ;
21882 void *argp1 = 0 ;
21883 int res1 = 0 ;
21884 bool temp2 = false ;
21885 PyObject * obj0 = 0 ;
21886 PyObject * obj1 = 0 ;
21887 char * kwnames[] = {
21888 (char *) "self",(char *) "s", NULL
21889 };
21890
21891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21893 if (!SWIG_IsOK(res1)) {
21894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21895 }
21896 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21897 {
21898 arg2 = wxString_in_helper(obj1);
21899 if (arg2 == NULL) SWIG_fail;
21900 temp2 = true;
21901 }
21902 {
21903 PyThreadState* __tstate = wxPyBeginAllowThreads();
21904 (arg1)->SetString((wxString const &)*arg2);
21905 wxPyEndAllowThreads(__tstate);
21906 if (PyErr_Occurred()) SWIG_fail;
21907 }
21908 resultobj = SWIG_Py_Void();
21909 {
21910 if (temp2)
21911 delete arg2;
21912 }
21913 return resultobj;
21914 fail:
21915 {
21916 if (temp2)
21917 delete arg2;
21918 }
21919 return NULL;
21920 }
21921
21922
21923 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21924 PyObject *resultobj = 0;
21925 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21926 wxString result;
21927 void *argp1 = 0 ;
21928 int res1 = 0 ;
21929 PyObject *swig_obj[1] ;
21930
21931 if (!args) SWIG_fail;
21932 swig_obj[0] = args;
21933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21934 if (!SWIG_IsOK(res1)) {
21935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21936 }
21937 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21938 {
21939 PyThreadState* __tstate = wxPyBeginAllowThreads();
21940 result = ((wxCommandEvent const *)arg1)->GetString();
21941 wxPyEndAllowThreads(__tstate);
21942 if (PyErr_Occurred()) SWIG_fail;
21943 }
21944 {
21945 #if wxUSE_UNICODE
21946 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21947 #else
21948 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21949 #endif
21950 }
21951 return resultobj;
21952 fail:
21953 return NULL;
21954 }
21955
21956
21957 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21958 PyObject *resultobj = 0;
21959 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21960 bool result;
21961 void *argp1 = 0 ;
21962 int res1 = 0 ;
21963 PyObject *swig_obj[1] ;
21964
21965 if (!args) SWIG_fail;
21966 swig_obj[0] = args;
21967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21968 if (!SWIG_IsOK(res1)) {
21969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21970 }
21971 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21972 {
21973 PyThreadState* __tstate = wxPyBeginAllowThreads();
21974 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
21975 wxPyEndAllowThreads(__tstate);
21976 if (PyErr_Occurred()) SWIG_fail;
21977 }
21978 {
21979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21980 }
21981 return resultobj;
21982 fail:
21983 return NULL;
21984 }
21985
21986
21987 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21988 PyObject *resultobj = 0;
21989 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21990 bool result;
21991 void *argp1 = 0 ;
21992 int res1 = 0 ;
21993 PyObject *swig_obj[1] ;
21994
21995 if (!args) SWIG_fail;
21996 swig_obj[0] = args;
21997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21998 if (!SWIG_IsOK(res1)) {
21999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22000 }
22001 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22002 {
22003 PyThreadState* __tstate = wxPyBeginAllowThreads();
22004 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
22005 wxPyEndAllowThreads(__tstate);
22006 if (PyErr_Occurred()) SWIG_fail;
22007 }
22008 {
22009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22010 }
22011 return resultobj;
22012 fail:
22013 return NULL;
22014 }
22015
22016
22017 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22018 PyObject *resultobj = 0;
22019 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22020 long arg2 ;
22021 void *argp1 = 0 ;
22022 int res1 = 0 ;
22023 long val2 ;
22024 int ecode2 = 0 ;
22025 PyObject * obj0 = 0 ;
22026 PyObject * obj1 = 0 ;
22027 char * kwnames[] = {
22028 (char *) "self",(char *) "extraLong", NULL
22029 };
22030
22031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
22032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22033 if (!SWIG_IsOK(res1)) {
22034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22035 }
22036 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22037 ecode2 = SWIG_AsVal_long(obj1, &val2);
22038 if (!SWIG_IsOK(ecode2)) {
22039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
22040 }
22041 arg2 = static_cast< long >(val2);
22042 {
22043 PyThreadState* __tstate = wxPyBeginAllowThreads();
22044 (arg1)->SetExtraLong(arg2);
22045 wxPyEndAllowThreads(__tstate);
22046 if (PyErr_Occurred()) SWIG_fail;
22047 }
22048 resultobj = SWIG_Py_Void();
22049 return resultobj;
22050 fail:
22051 return NULL;
22052 }
22053
22054
22055 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22056 PyObject *resultobj = 0;
22057 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22058 long result;
22059 void *argp1 = 0 ;
22060 int res1 = 0 ;
22061 PyObject *swig_obj[1] ;
22062
22063 if (!args) SWIG_fail;
22064 swig_obj[0] = args;
22065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22066 if (!SWIG_IsOK(res1)) {
22067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22068 }
22069 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22070 {
22071 PyThreadState* __tstate = wxPyBeginAllowThreads();
22072 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22073 wxPyEndAllowThreads(__tstate);
22074 if (PyErr_Occurred()) SWIG_fail;
22075 }
22076 resultobj = SWIG_From_long(static_cast< long >(result));
22077 return resultobj;
22078 fail:
22079 return NULL;
22080 }
22081
22082
22083 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22084 PyObject *resultobj = 0;
22085 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22086 int arg2 ;
22087 void *argp1 = 0 ;
22088 int res1 = 0 ;
22089 int val2 ;
22090 int ecode2 = 0 ;
22091 PyObject * obj0 = 0 ;
22092 PyObject * obj1 = 0 ;
22093 char * kwnames[] = {
22094 (char *) "self",(char *) "i", NULL
22095 };
22096
22097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22099 if (!SWIG_IsOK(res1)) {
22100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22101 }
22102 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22103 ecode2 = SWIG_AsVal_int(obj1, &val2);
22104 if (!SWIG_IsOK(ecode2)) {
22105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22106 }
22107 arg2 = static_cast< int >(val2);
22108 {
22109 PyThreadState* __tstate = wxPyBeginAllowThreads();
22110 (arg1)->SetInt(arg2);
22111 wxPyEndAllowThreads(__tstate);
22112 if (PyErr_Occurred()) SWIG_fail;
22113 }
22114 resultobj = SWIG_Py_Void();
22115 return resultobj;
22116 fail:
22117 return NULL;
22118 }
22119
22120
22121 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22122 PyObject *resultobj = 0;
22123 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22124 int result;
22125 void *argp1 = 0 ;
22126 int res1 = 0 ;
22127 PyObject *swig_obj[1] ;
22128
22129 if (!args) SWIG_fail;
22130 swig_obj[0] = args;
22131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22132 if (!SWIG_IsOK(res1)) {
22133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22134 }
22135 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22136 {
22137 PyThreadState* __tstate = wxPyBeginAllowThreads();
22138 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22139 wxPyEndAllowThreads(__tstate);
22140 if (PyErr_Occurred()) SWIG_fail;
22141 }
22142 resultobj = SWIG_From_int(static_cast< int >(result));
22143 return resultobj;
22144 fail:
22145 return NULL;
22146 }
22147
22148
22149 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22150 PyObject *resultobj = 0;
22151 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22152 PyObject *result = 0 ;
22153 void *argp1 = 0 ;
22154 int res1 = 0 ;
22155 PyObject *swig_obj[1] ;
22156
22157 if (!args) SWIG_fail;
22158 swig_obj[0] = args;
22159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22160 if (!SWIG_IsOK(res1)) {
22161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22162 }
22163 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22164 {
22165 PyThreadState* __tstate = wxPyBeginAllowThreads();
22166 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22167 wxPyEndAllowThreads(__tstate);
22168 if (PyErr_Occurred()) SWIG_fail;
22169 }
22170 resultobj = result;
22171 return resultobj;
22172 fail:
22173 return NULL;
22174 }
22175
22176
22177 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22178 PyObject *resultobj = 0;
22179 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22180 PyObject *arg2 = (PyObject *) 0 ;
22181 void *argp1 = 0 ;
22182 int res1 = 0 ;
22183 PyObject * obj0 = 0 ;
22184 PyObject * obj1 = 0 ;
22185 char * kwnames[] = {
22186 (char *) "self",(char *) "clientData", NULL
22187 };
22188
22189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22191 if (!SWIG_IsOK(res1)) {
22192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22193 }
22194 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22195 arg2 = obj1;
22196 {
22197 PyThreadState* __tstate = wxPyBeginAllowThreads();
22198 wxCommandEvent_SetClientData(arg1,arg2);
22199 wxPyEndAllowThreads(__tstate);
22200 if (PyErr_Occurred()) SWIG_fail;
22201 }
22202 resultobj = SWIG_Py_Void();
22203 return resultobj;
22204 fail:
22205 return NULL;
22206 }
22207
22208
22209 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22210 PyObject *resultobj = 0;
22211 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22212 wxEvent *result = 0 ;
22213 void *argp1 = 0 ;
22214 int res1 = 0 ;
22215 PyObject *swig_obj[1] ;
22216
22217 if (!args) SWIG_fail;
22218 swig_obj[0] = args;
22219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22220 if (!SWIG_IsOK(res1)) {
22221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22222 }
22223 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22224 {
22225 PyThreadState* __tstate = wxPyBeginAllowThreads();
22226 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22227 wxPyEndAllowThreads(__tstate);
22228 if (PyErr_Occurred()) SWIG_fail;
22229 }
22230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22231 return resultobj;
22232 fail:
22233 return NULL;
22234 }
22235
22236
22237 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22238 PyObject *obj;
22239 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22240 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22241 return SWIG_Py_Void();
22242 }
22243
22244 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22245 return SWIG_Python_InitShadowInstance(args);
22246 }
22247
22248 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22249 PyObject *resultobj = 0;
22250 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22251 int arg2 = (int) 0 ;
22252 wxNotifyEvent *result = 0 ;
22253 int val1 ;
22254 int ecode1 = 0 ;
22255 int val2 ;
22256 int ecode2 = 0 ;
22257 PyObject * obj0 = 0 ;
22258 PyObject * obj1 = 0 ;
22259 char * kwnames[] = {
22260 (char *) "commandType",(char *) "winid", NULL
22261 };
22262
22263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22264 if (obj0) {
22265 ecode1 = SWIG_AsVal_int(obj0, &val1);
22266 if (!SWIG_IsOK(ecode1)) {
22267 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22268 }
22269 arg1 = static_cast< wxEventType >(val1);
22270 }
22271 if (obj1) {
22272 ecode2 = SWIG_AsVal_int(obj1, &val2);
22273 if (!SWIG_IsOK(ecode2)) {
22274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22275 }
22276 arg2 = static_cast< int >(val2);
22277 }
22278 {
22279 PyThreadState* __tstate = wxPyBeginAllowThreads();
22280 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22281 wxPyEndAllowThreads(__tstate);
22282 if (PyErr_Occurred()) SWIG_fail;
22283 }
22284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22285 return resultobj;
22286 fail:
22287 return NULL;
22288 }
22289
22290
22291 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22292 PyObject *resultobj = 0;
22293 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
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_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22303 }
22304 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22305 {
22306 PyThreadState* __tstate = wxPyBeginAllowThreads();
22307 (arg1)->Veto();
22308 wxPyEndAllowThreads(__tstate);
22309 if (PyErr_Occurred()) SWIG_fail;
22310 }
22311 resultobj = SWIG_Py_Void();
22312 return resultobj;
22313 fail:
22314 return NULL;
22315 }
22316
22317
22318 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22319 PyObject *resultobj = 0;
22320 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22321 void *argp1 = 0 ;
22322 int res1 = 0 ;
22323 PyObject *swig_obj[1] ;
22324
22325 if (!args) SWIG_fail;
22326 swig_obj[0] = args;
22327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22328 if (!SWIG_IsOK(res1)) {
22329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22330 }
22331 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22332 {
22333 PyThreadState* __tstate = wxPyBeginAllowThreads();
22334 (arg1)->Allow();
22335 wxPyEndAllowThreads(__tstate);
22336 if (PyErr_Occurred()) SWIG_fail;
22337 }
22338 resultobj = SWIG_Py_Void();
22339 return resultobj;
22340 fail:
22341 return NULL;
22342 }
22343
22344
22345 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22346 PyObject *resultobj = 0;
22347 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22348 bool result;
22349 void *argp1 = 0 ;
22350 int res1 = 0 ;
22351 PyObject *swig_obj[1] ;
22352
22353 if (!args) SWIG_fail;
22354 swig_obj[0] = args;
22355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22356 if (!SWIG_IsOK(res1)) {
22357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22358 }
22359 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22360 {
22361 PyThreadState* __tstate = wxPyBeginAllowThreads();
22362 result = (bool)(arg1)->IsAllowed();
22363 wxPyEndAllowThreads(__tstate);
22364 if (PyErr_Occurred()) SWIG_fail;
22365 }
22366 {
22367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22368 }
22369 return resultobj;
22370 fail:
22371 return NULL;
22372 }
22373
22374
22375 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22376 PyObject *obj;
22377 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22378 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22379 return SWIG_Py_Void();
22380 }
22381
22382 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22383 return SWIG_Python_InitShadowInstance(args);
22384 }
22385
22386 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22387 PyObject *resultobj = 0;
22388 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22389 int arg2 = (int) 0 ;
22390 int arg3 = (int) 0 ;
22391 int arg4 = (int) 0 ;
22392 wxScrollEvent *result = 0 ;
22393 int val1 ;
22394 int ecode1 = 0 ;
22395 int val2 ;
22396 int ecode2 = 0 ;
22397 int val3 ;
22398 int ecode3 = 0 ;
22399 int val4 ;
22400 int ecode4 = 0 ;
22401 PyObject * obj0 = 0 ;
22402 PyObject * obj1 = 0 ;
22403 PyObject * obj2 = 0 ;
22404 PyObject * obj3 = 0 ;
22405 char * kwnames[] = {
22406 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22407 };
22408
22409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22410 if (obj0) {
22411 ecode1 = SWIG_AsVal_int(obj0, &val1);
22412 if (!SWIG_IsOK(ecode1)) {
22413 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22414 }
22415 arg1 = static_cast< wxEventType >(val1);
22416 }
22417 if (obj1) {
22418 ecode2 = SWIG_AsVal_int(obj1, &val2);
22419 if (!SWIG_IsOK(ecode2)) {
22420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22421 }
22422 arg2 = static_cast< int >(val2);
22423 }
22424 if (obj2) {
22425 ecode3 = SWIG_AsVal_int(obj2, &val3);
22426 if (!SWIG_IsOK(ecode3)) {
22427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22428 }
22429 arg3 = static_cast< int >(val3);
22430 }
22431 if (obj3) {
22432 ecode4 = SWIG_AsVal_int(obj3, &val4);
22433 if (!SWIG_IsOK(ecode4)) {
22434 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22435 }
22436 arg4 = static_cast< int >(val4);
22437 }
22438 {
22439 PyThreadState* __tstate = wxPyBeginAllowThreads();
22440 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22441 wxPyEndAllowThreads(__tstate);
22442 if (PyErr_Occurred()) SWIG_fail;
22443 }
22444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22445 return resultobj;
22446 fail:
22447 return NULL;
22448 }
22449
22450
22451 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22452 PyObject *resultobj = 0;
22453 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22454 int result;
22455 void *argp1 = 0 ;
22456 int res1 = 0 ;
22457 PyObject *swig_obj[1] ;
22458
22459 if (!args) SWIG_fail;
22460 swig_obj[0] = args;
22461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22462 if (!SWIG_IsOK(res1)) {
22463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22464 }
22465 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22466 {
22467 PyThreadState* __tstate = wxPyBeginAllowThreads();
22468 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22469 wxPyEndAllowThreads(__tstate);
22470 if (PyErr_Occurred()) SWIG_fail;
22471 }
22472 resultobj = SWIG_From_int(static_cast< int >(result));
22473 return resultobj;
22474 fail:
22475 return NULL;
22476 }
22477
22478
22479 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22480 PyObject *resultobj = 0;
22481 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22482 int result;
22483 void *argp1 = 0 ;
22484 int res1 = 0 ;
22485 PyObject *swig_obj[1] ;
22486
22487 if (!args) SWIG_fail;
22488 swig_obj[0] = args;
22489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22490 if (!SWIG_IsOK(res1)) {
22491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22492 }
22493 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22494 {
22495 PyThreadState* __tstate = wxPyBeginAllowThreads();
22496 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22497 wxPyEndAllowThreads(__tstate);
22498 if (PyErr_Occurred()) SWIG_fail;
22499 }
22500 resultobj = SWIG_From_int(static_cast< int >(result));
22501 return resultobj;
22502 fail:
22503 return NULL;
22504 }
22505
22506
22507 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22508 PyObject *resultobj = 0;
22509 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22510 int arg2 ;
22511 void *argp1 = 0 ;
22512 int res1 = 0 ;
22513 int val2 ;
22514 int ecode2 = 0 ;
22515 PyObject * obj0 = 0 ;
22516 PyObject * obj1 = 0 ;
22517 char * kwnames[] = {
22518 (char *) "self",(char *) "orient", NULL
22519 };
22520
22521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22523 if (!SWIG_IsOK(res1)) {
22524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22525 }
22526 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22527 ecode2 = SWIG_AsVal_int(obj1, &val2);
22528 if (!SWIG_IsOK(ecode2)) {
22529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22530 }
22531 arg2 = static_cast< int >(val2);
22532 {
22533 PyThreadState* __tstate = wxPyBeginAllowThreads();
22534 (arg1)->SetOrientation(arg2);
22535 wxPyEndAllowThreads(__tstate);
22536 if (PyErr_Occurred()) SWIG_fail;
22537 }
22538 resultobj = SWIG_Py_Void();
22539 return resultobj;
22540 fail:
22541 return NULL;
22542 }
22543
22544
22545 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22546 PyObject *resultobj = 0;
22547 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22548 int arg2 ;
22549 void *argp1 = 0 ;
22550 int res1 = 0 ;
22551 int val2 ;
22552 int ecode2 = 0 ;
22553 PyObject * obj0 = 0 ;
22554 PyObject * obj1 = 0 ;
22555 char * kwnames[] = {
22556 (char *) "self",(char *) "pos", NULL
22557 };
22558
22559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22561 if (!SWIG_IsOK(res1)) {
22562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22563 }
22564 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22565 ecode2 = SWIG_AsVal_int(obj1, &val2);
22566 if (!SWIG_IsOK(ecode2)) {
22567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22568 }
22569 arg2 = static_cast< int >(val2);
22570 {
22571 PyThreadState* __tstate = wxPyBeginAllowThreads();
22572 (arg1)->SetPosition(arg2);
22573 wxPyEndAllowThreads(__tstate);
22574 if (PyErr_Occurred()) SWIG_fail;
22575 }
22576 resultobj = SWIG_Py_Void();
22577 return resultobj;
22578 fail:
22579 return NULL;
22580 }
22581
22582
22583 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22584 PyObject *obj;
22585 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22586 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22587 return SWIG_Py_Void();
22588 }
22589
22590 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22591 return SWIG_Python_InitShadowInstance(args);
22592 }
22593
22594 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22595 PyObject *resultobj = 0;
22596 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22597 int arg2 = (int) 0 ;
22598 int arg3 = (int) 0 ;
22599 wxScrollWinEvent *result = 0 ;
22600 int val1 ;
22601 int ecode1 = 0 ;
22602 int val2 ;
22603 int ecode2 = 0 ;
22604 int val3 ;
22605 int ecode3 = 0 ;
22606 PyObject * obj0 = 0 ;
22607 PyObject * obj1 = 0 ;
22608 PyObject * obj2 = 0 ;
22609 char * kwnames[] = {
22610 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22611 };
22612
22613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22614 if (obj0) {
22615 ecode1 = SWIG_AsVal_int(obj0, &val1);
22616 if (!SWIG_IsOK(ecode1)) {
22617 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22618 }
22619 arg1 = static_cast< wxEventType >(val1);
22620 }
22621 if (obj1) {
22622 ecode2 = SWIG_AsVal_int(obj1, &val2);
22623 if (!SWIG_IsOK(ecode2)) {
22624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22625 }
22626 arg2 = static_cast< int >(val2);
22627 }
22628 if (obj2) {
22629 ecode3 = SWIG_AsVal_int(obj2, &val3);
22630 if (!SWIG_IsOK(ecode3)) {
22631 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22632 }
22633 arg3 = static_cast< int >(val3);
22634 }
22635 {
22636 PyThreadState* __tstate = wxPyBeginAllowThreads();
22637 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22638 wxPyEndAllowThreads(__tstate);
22639 if (PyErr_Occurred()) SWIG_fail;
22640 }
22641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22642 return resultobj;
22643 fail:
22644 return NULL;
22645 }
22646
22647
22648 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22649 PyObject *resultobj = 0;
22650 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22651 int result;
22652 void *argp1 = 0 ;
22653 int res1 = 0 ;
22654 PyObject *swig_obj[1] ;
22655
22656 if (!args) SWIG_fail;
22657 swig_obj[0] = args;
22658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22659 if (!SWIG_IsOK(res1)) {
22660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22661 }
22662 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22663 {
22664 PyThreadState* __tstate = wxPyBeginAllowThreads();
22665 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22666 wxPyEndAllowThreads(__tstate);
22667 if (PyErr_Occurred()) SWIG_fail;
22668 }
22669 resultobj = SWIG_From_int(static_cast< int >(result));
22670 return resultobj;
22671 fail:
22672 return NULL;
22673 }
22674
22675
22676 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22677 PyObject *resultobj = 0;
22678 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22679 int result;
22680 void *argp1 = 0 ;
22681 int res1 = 0 ;
22682 PyObject *swig_obj[1] ;
22683
22684 if (!args) SWIG_fail;
22685 swig_obj[0] = args;
22686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22687 if (!SWIG_IsOK(res1)) {
22688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22689 }
22690 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22691 {
22692 PyThreadState* __tstate = wxPyBeginAllowThreads();
22693 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22694 wxPyEndAllowThreads(__tstate);
22695 if (PyErr_Occurred()) SWIG_fail;
22696 }
22697 resultobj = SWIG_From_int(static_cast< int >(result));
22698 return resultobj;
22699 fail:
22700 return NULL;
22701 }
22702
22703
22704 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22705 PyObject *resultobj = 0;
22706 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22707 int arg2 ;
22708 void *argp1 = 0 ;
22709 int res1 = 0 ;
22710 int val2 ;
22711 int ecode2 = 0 ;
22712 PyObject * obj0 = 0 ;
22713 PyObject * obj1 = 0 ;
22714 char * kwnames[] = {
22715 (char *) "self",(char *) "orient", NULL
22716 };
22717
22718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22720 if (!SWIG_IsOK(res1)) {
22721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22722 }
22723 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22724 ecode2 = SWIG_AsVal_int(obj1, &val2);
22725 if (!SWIG_IsOK(ecode2)) {
22726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22727 }
22728 arg2 = static_cast< int >(val2);
22729 {
22730 PyThreadState* __tstate = wxPyBeginAllowThreads();
22731 (arg1)->SetOrientation(arg2);
22732 wxPyEndAllowThreads(__tstate);
22733 if (PyErr_Occurred()) SWIG_fail;
22734 }
22735 resultobj = SWIG_Py_Void();
22736 return resultobj;
22737 fail:
22738 return NULL;
22739 }
22740
22741
22742 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22743 PyObject *resultobj = 0;
22744 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22745 int arg2 ;
22746 void *argp1 = 0 ;
22747 int res1 = 0 ;
22748 int val2 ;
22749 int ecode2 = 0 ;
22750 PyObject * obj0 = 0 ;
22751 PyObject * obj1 = 0 ;
22752 char * kwnames[] = {
22753 (char *) "self",(char *) "pos", NULL
22754 };
22755
22756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22758 if (!SWIG_IsOK(res1)) {
22759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22760 }
22761 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22762 ecode2 = SWIG_AsVal_int(obj1, &val2);
22763 if (!SWIG_IsOK(ecode2)) {
22764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22765 }
22766 arg2 = static_cast< int >(val2);
22767 {
22768 PyThreadState* __tstate = wxPyBeginAllowThreads();
22769 (arg1)->SetPosition(arg2);
22770 wxPyEndAllowThreads(__tstate);
22771 if (PyErr_Occurred()) SWIG_fail;
22772 }
22773 resultobj = SWIG_Py_Void();
22774 return resultobj;
22775 fail:
22776 return NULL;
22777 }
22778
22779
22780 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22781 PyObject *obj;
22782 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22783 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22784 return SWIG_Py_Void();
22785 }
22786
22787 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22788 return SWIG_Python_InitShadowInstance(args);
22789 }
22790
22791 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22792 PyObject *resultobj = 0;
22793 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22794 wxMouseEvent *result = 0 ;
22795 int val1 ;
22796 int ecode1 = 0 ;
22797 PyObject * obj0 = 0 ;
22798 char * kwnames[] = {
22799 (char *) "mouseType", NULL
22800 };
22801
22802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22803 if (obj0) {
22804 ecode1 = SWIG_AsVal_int(obj0, &val1);
22805 if (!SWIG_IsOK(ecode1)) {
22806 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22807 }
22808 arg1 = static_cast< wxEventType >(val1);
22809 }
22810 {
22811 PyThreadState* __tstate = wxPyBeginAllowThreads();
22812 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22813 wxPyEndAllowThreads(__tstate);
22814 if (PyErr_Occurred()) SWIG_fail;
22815 }
22816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22817 return resultobj;
22818 fail:
22819 return NULL;
22820 }
22821
22822
22823 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22824 PyObject *resultobj = 0;
22825 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22826 bool result;
22827 void *argp1 = 0 ;
22828 int res1 = 0 ;
22829 PyObject *swig_obj[1] ;
22830
22831 if (!args) SWIG_fail;
22832 swig_obj[0] = args;
22833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22834 if (!SWIG_IsOK(res1)) {
22835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22836 }
22837 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22838 {
22839 PyThreadState* __tstate = wxPyBeginAllowThreads();
22840 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22841 wxPyEndAllowThreads(__tstate);
22842 if (PyErr_Occurred()) SWIG_fail;
22843 }
22844 {
22845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22846 }
22847 return resultobj;
22848 fail:
22849 return NULL;
22850 }
22851
22852
22853 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22854 PyObject *resultobj = 0;
22855 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22856 int arg2 = (int) wxMOUSE_BTN_ANY ;
22857 bool result;
22858 void *argp1 = 0 ;
22859 int res1 = 0 ;
22860 int val2 ;
22861 int ecode2 = 0 ;
22862 PyObject * obj0 = 0 ;
22863 PyObject * obj1 = 0 ;
22864 char * kwnames[] = {
22865 (char *) "self",(char *) "but", NULL
22866 };
22867
22868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22870 if (!SWIG_IsOK(res1)) {
22871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22872 }
22873 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22874 if (obj1) {
22875 ecode2 = SWIG_AsVal_int(obj1, &val2);
22876 if (!SWIG_IsOK(ecode2)) {
22877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22878 }
22879 arg2 = static_cast< int >(val2);
22880 }
22881 {
22882 PyThreadState* __tstate = wxPyBeginAllowThreads();
22883 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22884 wxPyEndAllowThreads(__tstate);
22885 if (PyErr_Occurred()) SWIG_fail;
22886 }
22887 {
22888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22889 }
22890 return resultobj;
22891 fail:
22892 return NULL;
22893 }
22894
22895
22896 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22897 PyObject *resultobj = 0;
22898 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22899 int arg2 = (int) wxMOUSE_BTN_ANY ;
22900 bool result;
22901 void *argp1 = 0 ;
22902 int res1 = 0 ;
22903 int val2 ;
22904 int ecode2 = 0 ;
22905 PyObject * obj0 = 0 ;
22906 PyObject * obj1 = 0 ;
22907 char * kwnames[] = {
22908 (char *) "self",(char *) "but", NULL
22909 };
22910
22911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22913 if (!SWIG_IsOK(res1)) {
22914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22915 }
22916 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22917 if (obj1) {
22918 ecode2 = SWIG_AsVal_int(obj1, &val2);
22919 if (!SWIG_IsOK(ecode2)) {
22920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22921 }
22922 arg2 = static_cast< int >(val2);
22923 }
22924 {
22925 PyThreadState* __tstate = wxPyBeginAllowThreads();
22926 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22927 wxPyEndAllowThreads(__tstate);
22928 if (PyErr_Occurred()) SWIG_fail;
22929 }
22930 {
22931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22932 }
22933 return resultobj;
22934 fail:
22935 return NULL;
22936 }
22937
22938
22939 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22940 PyObject *resultobj = 0;
22941 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22942 int arg2 = (int) wxMOUSE_BTN_ANY ;
22943 bool result;
22944 void *argp1 = 0 ;
22945 int res1 = 0 ;
22946 int val2 ;
22947 int ecode2 = 0 ;
22948 PyObject * obj0 = 0 ;
22949 PyObject * obj1 = 0 ;
22950 char * kwnames[] = {
22951 (char *) "self",(char *) "but", NULL
22952 };
22953
22954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22956 if (!SWIG_IsOK(res1)) {
22957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22958 }
22959 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22960 if (obj1) {
22961 ecode2 = SWIG_AsVal_int(obj1, &val2);
22962 if (!SWIG_IsOK(ecode2)) {
22963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22964 }
22965 arg2 = static_cast< int >(val2);
22966 }
22967 {
22968 PyThreadState* __tstate = wxPyBeginAllowThreads();
22969 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22970 wxPyEndAllowThreads(__tstate);
22971 if (PyErr_Occurred()) SWIG_fail;
22972 }
22973 {
22974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22975 }
22976 return resultobj;
22977 fail:
22978 return NULL;
22979 }
22980
22981
22982 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22983 PyObject *resultobj = 0;
22984 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22985 int arg2 ;
22986 bool result;
22987 void *argp1 = 0 ;
22988 int res1 = 0 ;
22989 int val2 ;
22990 int ecode2 = 0 ;
22991 PyObject * obj0 = 0 ;
22992 PyObject * obj1 = 0 ;
22993 char * kwnames[] = {
22994 (char *) "self",(char *) "button", NULL
22995 };
22996
22997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
22998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22999 if (!SWIG_IsOK(res1)) {
23000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23001 }
23002 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23003 ecode2 = SWIG_AsVal_int(obj1, &val2);
23004 if (!SWIG_IsOK(ecode2)) {
23005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
23006 }
23007 arg2 = static_cast< int >(val2);
23008 {
23009 PyThreadState* __tstate = wxPyBeginAllowThreads();
23010 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
23011 wxPyEndAllowThreads(__tstate);
23012 if (PyErr_Occurred()) SWIG_fail;
23013 }
23014 {
23015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23016 }
23017 return resultobj;
23018 fail:
23019 return NULL;
23020 }
23021
23022
23023 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23024 PyObject *resultobj = 0;
23025 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23026 int arg2 ;
23027 bool result;
23028 void *argp1 = 0 ;
23029 int res1 = 0 ;
23030 int val2 ;
23031 int ecode2 = 0 ;
23032 PyObject * obj0 = 0 ;
23033 PyObject * obj1 = 0 ;
23034 char * kwnames[] = {
23035 (char *) "self",(char *) "but", NULL
23036 };
23037
23038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
23039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23040 if (!SWIG_IsOK(res1)) {
23041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23042 }
23043 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23044 ecode2 = SWIG_AsVal_int(obj1, &val2);
23045 if (!SWIG_IsOK(ecode2)) {
23046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
23047 }
23048 arg2 = static_cast< int >(val2);
23049 {
23050 PyThreadState* __tstate = wxPyBeginAllowThreads();
23051 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
23052 wxPyEndAllowThreads(__tstate);
23053 if (PyErr_Occurred()) SWIG_fail;
23054 }
23055 {
23056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23057 }
23058 return resultobj;
23059 fail:
23060 return NULL;
23061 }
23062
23063
23064 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23065 PyObject *resultobj = 0;
23066 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23067 int result;
23068 void *argp1 = 0 ;
23069 int res1 = 0 ;
23070 PyObject *swig_obj[1] ;
23071
23072 if (!args) SWIG_fail;
23073 swig_obj[0] = args;
23074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23075 if (!SWIG_IsOK(res1)) {
23076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23077 }
23078 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23079 {
23080 PyThreadState* __tstate = wxPyBeginAllowThreads();
23081 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23082 wxPyEndAllowThreads(__tstate);
23083 if (PyErr_Occurred()) SWIG_fail;
23084 }
23085 resultobj = SWIG_From_int(static_cast< int >(result));
23086 return resultobj;
23087 fail:
23088 return NULL;
23089 }
23090
23091
23092 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23093 PyObject *resultobj = 0;
23094 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23095 bool result;
23096 void *argp1 = 0 ;
23097 int res1 = 0 ;
23098 PyObject *swig_obj[1] ;
23099
23100 if (!args) SWIG_fail;
23101 swig_obj[0] = args;
23102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23103 if (!SWIG_IsOK(res1)) {
23104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23105 }
23106 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23107 {
23108 PyThreadState* __tstate = wxPyBeginAllowThreads();
23109 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23110 wxPyEndAllowThreads(__tstate);
23111 if (PyErr_Occurred()) SWIG_fail;
23112 }
23113 {
23114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23115 }
23116 return resultobj;
23117 fail:
23118 return NULL;
23119 }
23120
23121
23122 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23123 PyObject *resultobj = 0;
23124 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23125 bool result;
23126 void *argp1 = 0 ;
23127 int res1 = 0 ;
23128 PyObject *swig_obj[1] ;
23129
23130 if (!args) SWIG_fail;
23131 swig_obj[0] = args;
23132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23133 if (!SWIG_IsOK(res1)) {
23134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23135 }
23136 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23137 {
23138 PyThreadState* __tstate = wxPyBeginAllowThreads();
23139 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23140 wxPyEndAllowThreads(__tstate);
23141 if (PyErr_Occurred()) SWIG_fail;
23142 }
23143 {
23144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23145 }
23146 return resultobj;
23147 fail:
23148 return NULL;
23149 }
23150
23151
23152 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23153 PyObject *resultobj = 0;
23154 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23155 bool result;
23156 void *argp1 = 0 ;
23157 int res1 = 0 ;
23158 PyObject *swig_obj[1] ;
23159
23160 if (!args) SWIG_fail;
23161 swig_obj[0] = args;
23162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23163 if (!SWIG_IsOK(res1)) {
23164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23165 }
23166 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23167 {
23168 PyThreadState* __tstate = wxPyBeginAllowThreads();
23169 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23170 wxPyEndAllowThreads(__tstate);
23171 if (PyErr_Occurred()) SWIG_fail;
23172 }
23173 {
23174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23175 }
23176 return resultobj;
23177 fail:
23178 return NULL;
23179 }
23180
23181
23182 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23183 PyObject *resultobj = 0;
23184 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23185 bool result;
23186 void *argp1 = 0 ;
23187 int res1 = 0 ;
23188 PyObject *swig_obj[1] ;
23189
23190 if (!args) SWIG_fail;
23191 swig_obj[0] = args;
23192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23193 if (!SWIG_IsOK(res1)) {
23194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23195 }
23196 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23197 {
23198 PyThreadState* __tstate = wxPyBeginAllowThreads();
23199 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23200 wxPyEndAllowThreads(__tstate);
23201 if (PyErr_Occurred()) SWIG_fail;
23202 }
23203 {
23204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23205 }
23206 return resultobj;
23207 fail:
23208 return NULL;
23209 }
23210
23211
23212 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23213 PyObject *resultobj = 0;
23214 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23215 bool result;
23216 void *argp1 = 0 ;
23217 int res1 = 0 ;
23218 PyObject *swig_obj[1] ;
23219
23220 if (!args) SWIG_fail;
23221 swig_obj[0] = args;
23222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23223 if (!SWIG_IsOK(res1)) {
23224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23225 }
23226 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23227 {
23228 PyThreadState* __tstate = wxPyBeginAllowThreads();
23229 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23230 wxPyEndAllowThreads(__tstate);
23231 if (PyErr_Occurred()) SWIG_fail;
23232 }
23233 {
23234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23235 }
23236 return resultobj;
23237 fail:
23238 return NULL;
23239 }
23240
23241
23242 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23243 PyObject *resultobj = 0;
23244 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23245 bool result;
23246 void *argp1 = 0 ;
23247 int res1 = 0 ;
23248 PyObject *swig_obj[1] ;
23249
23250 if (!args) SWIG_fail;
23251 swig_obj[0] = args;
23252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23253 if (!SWIG_IsOK(res1)) {
23254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23255 }
23256 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23257 {
23258 PyThreadState* __tstate = wxPyBeginAllowThreads();
23259 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23260 wxPyEndAllowThreads(__tstate);
23261 if (PyErr_Occurred()) SWIG_fail;
23262 }
23263 {
23264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23265 }
23266 return resultobj;
23267 fail:
23268 return NULL;
23269 }
23270
23271
23272 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23273 PyObject *resultobj = 0;
23274 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23275 bool result;
23276 void *argp1 = 0 ;
23277 int res1 = 0 ;
23278 PyObject *swig_obj[1] ;
23279
23280 if (!args) SWIG_fail;
23281 swig_obj[0] = args;
23282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23283 if (!SWIG_IsOK(res1)) {
23284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23285 }
23286 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23287 {
23288 PyThreadState* __tstate = wxPyBeginAllowThreads();
23289 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23290 wxPyEndAllowThreads(__tstate);
23291 if (PyErr_Occurred()) SWIG_fail;
23292 }
23293 {
23294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23295 }
23296 return resultobj;
23297 fail:
23298 return NULL;
23299 }
23300
23301
23302 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23303 PyObject *resultobj = 0;
23304 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23305 bool result;
23306 void *argp1 = 0 ;
23307 int res1 = 0 ;
23308 PyObject *swig_obj[1] ;
23309
23310 if (!args) SWIG_fail;
23311 swig_obj[0] = args;
23312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23313 if (!SWIG_IsOK(res1)) {
23314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23315 }
23316 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23317 {
23318 PyThreadState* __tstate = wxPyBeginAllowThreads();
23319 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23320 wxPyEndAllowThreads(__tstate);
23321 if (PyErr_Occurred()) SWIG_fail;
23322 }
23323 {
23324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23325 }
23326 return resultobj;
23327 fail:
23328 return NULL;
23329 }
23330
23331
23332 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23333 PyObject *resultobj = 0;
23334 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23335 bool result;
23336 void *argp1 = 0 ;
23337 int res1 = 0 ;
23338 PyObject *swig_obj[1] ;
23339
23340 if (!args) SWIG_fail;
23341 swig_obj[0] = args;
23342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23343 if (!SWIG_IsOK(res1)) {
23344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23345 }
23346 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23347 {
23348 PyThreadState* __tstate = wxPyBeginAllowThreads();
23349 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23350 wxPyEndAllowThreads(__tstate);
23351 if (PyErr_Occurred()) SWIG_fail;
23352 }
23353 {
23354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23355 }
23356 return resultobj;
23357 fail:
23358 return NULL;
23359 }
23360
23361
23362 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23363 PyObject *resultobj = 0;
23364 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23365 bool result;
23366 void *argp1 = 0 ;
23367 int res1 = 0 ;
23368 PyObject *swig_obj[1] ;
23369
23370 if (!args) SWIG_fail;
23371 swig_obj[0] = args;
23372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23373 if (!SWIG_IsOK(res1)) {
23374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23375 }
23376 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23377 {
23378 PyThreadState* __tstate = wxPyBeginAllowThreads();
23379 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23380 wxPyEndAllowThreads(__tstate);
23381 if (PyErr_Occurred()) SWIG_fail;
23382 }
23383 {
23384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23385 }
23386 return resultobj;
23387 fail:
23388 return NULL;
23389 }
23390
23391
23392 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23393 PyObject *resultobj = 0;
23394 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23395 bool result;
23396 void *argp1 = 0 ;
23397 int res1 = 0 ;
23398 PyObject *swig_obj[1] ;
23399
23400 if (!args) SWIG_fail;
23401 swig_obj[0] = args;
23402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23403 if (!SWIG_IsOK(res1)) {
23404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23405 }
23406 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23407 {
23408 PyThreadState* __tstate = wxPyBeginAllowThreads();
23409 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23410 wxPyEndAllowThreads(__tstate);
23411 if (PyErr_Occurred()) SWIG_fail;
23412 }
23413 {
23414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23415 }
23416 return resultobj;
23417 fail:
23418 return NULL;
23419 }
23420
23421
23422 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23423 PyObject *resultobj = 0;
23424 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23425 bool result;
23426 void *argp1 = 0 ;
23427 int res1 = 0 ;
23428 PyObject *swig_obj[1] ;
23429
23430 if (!args) SWIG_fail;
23431 swig_obj[0] = args;
23432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23433 if (!SWIG_IsOK(res1)) {
23434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23435 }
23436 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23437 {
23438 PyThreadState* __tstate = wxPyBeginAllowThreads();
23439 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23440 wxPyEndAllowThreads(__tstate);
23441 if (PyErr_Occurred()) SWIG_fail;
23442 }
23443 {
23444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23445 }
23446 return resultobj;
23447 fail:
23448 return NULL;
23449 }
23450
23451
23452 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23453 PyObject *resultobj = 0;
23454 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23455 bool result;
23456 void *argp1 = 0 ;
23457 int res1 = 0 ;
23458 PyObject *swig_obj[1] ;
23459
23460 if (!args) SWIG_fail;
23461 swig_obj[0] = args;
23462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23463 if (!SWIG_IsOK(res1)) {
23464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23465 }
23466 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23467 {
23468 PyThreadState* __tstate = wxPyBeginAllowThreads();
23469 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23470 wxPyEndAllowThreads(__tstate);
23471 if (PyErr_Occurred()) SWIG_fail;
23472 }
23473 {
23474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23475 }
23476 return resultobj;
23477 fail:
23478 return NULL;
23479 }
23480
23481
23482 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23483 PyObject *resultobj = 0;
23484 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23485 bool result;
23486 void *argp1 = 0 ;
23487 int res1 = 0 ;
23488 PyObject *swig_obj[1] ;
23489
23490 if (!args) SWIG_fail;
23491 swig_obj[0] = args;
23492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23493 if (!SWIG_IsOK(res1)) {
23494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23495 }
23496 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23497 {
23498 PyThreadState* __tstate = wxPyBeginAllowThreads();
23499 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23500 wxPyEndAllowThreads(__tstate);
23501 if (PyErr_Occurred()) SWIG_fail;
23502 }
23503 {
23504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23505 }
23506 return resultobj;
23507 fail:
23508 return NULL;
23509 }
23510
23511
23512 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23513 PyObject *resultobj = 0;
23514 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23515 bool result;
23516 void *argp1 = 0 ;
23517 int res1 = 0 ;
23518 PyObject *swig_obj[1] ;
23519
23520 if (!args) SWIG_fail;
23521 swig_obj[0] = args;
23522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23523 if (!SWIG_IsOK(res1)) {
23524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23525 }
23526 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23527 {
23528 PyThreadState* __tstate = wxPyBeginAllowThreads();
23529 result = (bool)(arg1)->LeftIsDown();
23530 wxPyEndAllowThreads(__tstate);
23531 if (PyErr_Occurred()) SWIG_fail;
23532 }
23533 {
23534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23535 }
23536 return resultobj;
23537 fail:
23538 return NULL;
23539 }
23540
23541
23542 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23543 PyObject *resultobj = 0;
23544 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23545 bool result;
23546 void *argp1 = 0 ;
23547 int res1 = 0 ;
23548 PyObject *swig_obj[1] ;
23549
23550 if (!args) SWIG_fail;
23551 swig_obj[0] = args;
23552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23553 if (!SWIG_IsOK(res1)) {
23554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23555 }
23556 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23557 {
23558 PyThreadState* __tstate = wxPyBeginAllowThreads();
23559 result = (bool)(arg1)->MiddleIsDown();
23560 wxPyEndAllowThreads(__tstate);
23561 if (PyErr_Occurred()) SWIG_fail;
23562 }
23563 {
23564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23565 }
23566 return resultobj;
23567 fail:
23568 return NULL;
23569 }
23570
23571
23572 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23573 PyObject *resultobj = 0;
23574 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23575 bool result;
23576 void *argp1 = 0 ;
23577 int res1 = 0 ;
23578 PyObject *swig_obj[1] ;
23579
23580 if (!args) SWIG_fail;
23581 swig_obj[0] = args;
23582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23583 if (!SWIG_IsOK(res1)) {
23584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23585 }
23586 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23587 {
23588 PyThreadState* __tstate = wxPyBeginAllowThreads();
23589 result = (bool)(arg1)->RightIsDown();
23590 wxPyEndAllowThreads(__tstate);
23591 if (PyErr_Occurred()) SWIG_fail;
23592 }
23593 {
23594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23595 }
23596 return resultobj;
23597 fail:
23598 return NULL;
23599 }
23600
23601
23602 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23603 PyObject *resultobj = 0;
23604 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23605 bool result;
23606 void *argp1 = 0 ;
23607 int res1 = 0 ;
23608 PyObject *swig_obj[1] ;
23609
23610 if (!args) SWIG_fail;
23611 swig_obj[0] = args;
23612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23613 if (!SWIG_IsOK(res1)) {
23614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23615 }
23616 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23617 {
23618 PyThreadState* __tstate = wxPyBeginAllowThreads();
23619 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23620 wxPyEndAllowThreads(__tstate);
23621 if (PyErr_Occurred()) SWIG_fail;
23622 }
23623 {
23624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23625 }
23626 return resultobj;
23627 fail:
23628 return NULL;
23629 }
23630
23631
23632 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23633 PyObject *resultobj = 0;
23634 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23635 bool result;
23636 void *argp1 = 0 ;
23637 int res1 = 0 ;
23638 PyObject *swig_obj[1] ;
23639
23640 if (!args) SWIG_fail;
23641 swig_obj[0] = args;
23642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23643 if (!SWIG_IsOK(res1)) {
23644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23645 }
23646 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23647 {
23648 PyThreadState* __tstate = wxPyBeginAllowThreads();
23649 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23650 wxPyEndAllowThreads(__tstate);
23651 if (PyErr_Occurred()) SWIG_fail;
23652 }
23653 {
23654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23655 }
23656 return resultobj;
23657 fail:
23658 return NULL;
23659 }
23660
23661
23662 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23663 PyObject *resultobj = 0;
23664 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23665 bool result;
23666 void *argp1 = 0 ;
23667 int res1 = 0 ;
23668 PyObject *swig_obj[1] ;
23669
23670 if (!args) SWIG_fail;
23671 swig_obj[0] = args;
23672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23673 if (!SWIG_IsOK(res1)) {
23674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23675 }
23676 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23677 {
23678 PyThreadState* __tstate = wxPyBeginAllowThreads();
23679 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23680 wxPyEndAllowThreads(__tstate);
23681 if (PyErr_Occurred()) SWIG_fail;
23682 }
23683 {
23684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23685 }
23686 return resultobj;
23687 fail:
23688 return NULL;
23689 }
23690
23691
23692 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23693 PyObject *resultobj = 0;
23694 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23695 bool result;
23696 void *argp1 = 0 ;
23697 int res1 = 0 ;
23698 PyObject *swig_obj[1] ;
23699
23700 if (!args) SWIG_fail;
23701 swig_obj[0] = args;
23702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23703 if (!SWIG_IsOK(res1)) {
23704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23705 }
23706 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23707 {
23708 PyThreadState* __tstate = wxPyBeginAllowThreads();
23709 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23710 wxPyEndAllowThreads(__tstate);
23711 if (PyErr_Occurred()) SWIG_fail;
23712 }
23713 {
23714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23715 }
23716 return resultobj;
23717 fail:
23718 return NULL;
23719 }
23720
23721
23722 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23723 PyObject *resultobj = 0;
23724 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23725 wxPoint result;
23726 void *argp1 = 0 ;
23727 int res1 = 0 ;
23728 PyObject *swig_obj[1] ;
23729
23730 if (!args) SWIG_fail;
23731 swig_obj[0] = args;
23732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23733 if (!SWIG_IsOK(res1)) {
23734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23735 }
23736 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23737 {
23738 PyThreadState* __tstate = wxPyBeginAllowThreads();
23739 result = (arg1)->GetPosition();
23740 wxPyEndAllowThreads(__tstate);
23741 if (PyErr_Occurred()) SWIG_fail;
23742 }
23743 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23744 return resultobj;
23745 fail:
23746 return NULL;
23747 }
23748
23749
23750 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23751 PyObject *resultobj = 0;
23752 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23753 long *arg2 = (long *) 0 ;
23754 long *arg3 = (long *) 0 ;
23755 void *argp1 = 0 ;
23756 int res1 = 0 ;
23757 long temp2 ;
23758 int res2 = SWIG_TMPOBJ ;
23759 long temp3 ;
23760 int res3 = SWIG_TMPOBJ ;
23761 PyObject *swig_obj[1] ;
23762
23763 arg2 = &temp2;
23764 arg3 = &temp3;
23765 if (!args) SWIG_fail;
23766 swig_obj[0] = args;
23767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23768 if (!SWIG_IsOK(res1)) {
23769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23770 }
23771 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23772 {
23773 PyThreadState* __tstate = wxPyBeginAllowThreads();
23774 (arg1)->GetPosition(arg2,arg3);
23775 wxPyEndAllowThreads(__tstate);
23776 if (PyErr_Occurred()) SWIG_fail;
23777 }
23778 resultobj = SWIG_Py_Void();
23779 if (SWIG_IsTmpObj(res2)) {
23780 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23781 } else {
23782 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23783 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23784 }
23785 if (SWIG_IsTmpObj(res3)) {
23786 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23787 } else {
23788 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23789 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23790 }
23791 return resultobj;
23792 fail:
23793 return NULL;
23794 }
23795
23796
23797 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23798 PyObject *resultobj = 0;
23799 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23800 wxDC *arg2 = 0 ;
23801 wxPoint result;
23802 void *argp1 = 0 ;
23803 int res1 = 0 ;
23804 void *argp2 = 0 ;
23805 int res2 = 0 ;
23806 PyObject * obj0 = 0 ;
23807 PyObject * obj1 = 0 ;
23808 char * kwnames[] = {
23809 (char *) "self",(char *) "dc", NULL
23810 };
23811
23812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23814 if (!SWIG_IsOK(res1)) {
23815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23816 }
23817 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23818 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23819 if (!SWIG_IsOK(res2)) {
23820 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23821 }
23822 if (!argp2) {
23823 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23824 }
23825 arg2 = reinterpret_cast< wxDC * >(argp2);
23826 {
23827 PyThreadState* __tstate = wxPyBeginAllowThreads();
23828 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23829 wxPyEndAllowThreads(__tstate);
23830 if (PyErr_Occurred()) SWIG_fail;
23831 }
23832 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23833 return resultobj;
23834 fail:
23835 return NULL;
23836 }
23837
23838
23839 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23840 PyObject *resultobj = 0;
23841 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23842 int result;
23843 void *argp1 = 0 ;
23844 int res1 = 0 ;
23845 PyObject *swig_obj[1] ;
23846
23847 if (!args) SWIG_fail;
23848 swig_obj[0] = args;
23849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23850 if (!SWIG_IsOK(res1)) {
23851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23852 }
23853 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23854 {
23855 PyThreadState* __tstate = wxPyBeginAllowThreads();
23856 result = (int)((wxMouseEvent const *)arg1)->GetX();
23857 wxPyEndAllowThreads(__tstate);
23858 if (PyErr_Occurred()) SWIG_fail;
23859 }
23860 resultobj = SWIG_From_int(static_cast< int >(result));
23861 return resultobj;
23862 fail:
23863 return NULL;
23864 }
23865
23866
23867 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23868 PyObject *resultobj = 0;
23869 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23870 int result;
23871 void *argp1 = 0 ;
23872 int res1 = 0 ;
23873 PyObject *swig_obj[1] ;
23874
23875 if (!args) SWIG_fail;
23876 swig_obj[0] = args;
23877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23878 if (!SWIG_IsOK(res1)) {
23879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23880 }
23881 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23882 {
23883 PyThreadState* __tstate = wxPyBeginAllowThreads();
23884 result = (int)((wxMouseEvent const *)arg1)->GetY();
23885 wxPyEndAllowThreads(__tstate);
23886 if (PyErr_Occurred()) SWIG_fail;
23887 }
23888 resultobj = SWIG_From_int(static_cast< int >(result));
23889 return resultobj;
23890 fail:
23891 return NULL;
23892 }
23893
23894
23895 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23896 PyObject *resultobj = 0;
23897 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23898 int result;
23899 void *argp1 = 0 ;
23900 int res1 = 0 ;
23901 PyObject *swig_obj[1] ;
23902
23903 if (!args) SWIG_fail;
23904 swig_obj[0] = args;
23905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23906 if (!SWIG_IsOK(res1)) {
23907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23908 }
23909 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23910 {
23911 PyThreadState* __tstate = wxPyBeginAllowThreads();
23912 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23913 wxPyEndAllowThreads(__tstate);
23914 if (PyErr_Occurred()) SWIG_fail;
23915 }
23916 resultobj = SWIG_From_int(static_cast< int >(result));
23917 return resultobj;
23918 fail:
23919 return NULL;
23920 }
23921
23922
23923 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23924 PyObject *resultobj = 0;
23925 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23926 int result;
23927 void *argp1 = 0 ;
23928 int res1 = 0 ;
23929 PyObject *swig_obj[1] ;
23930
23931 if (!args) SWIG_fail;
23932 swig_obj[0] = args;
23933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23934 if (!SWIG_IsOK(res1)) {
23935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23936 }
23937 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23938 {
23939 PyThreadState* __tstate = wxPyBeginAllowThreads();
23940 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23941 wxPyEndAllowThreads(__tstate);
23942 if (PyErr_Occurred()) SWIG_fail;
23943 }
23944 resultobj = SWIG_From_int(static_cast< int >(result));
23945 return resultobj;
23946 fail:
23947 return NULL;
23948 }
23949
23950
23951 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelAxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23952 PyObject *resultobj = 0;
23953 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23954 int result;
23955 void *argp1 = 0 ;
23956 int res1 = 0 ;
23957 PyObject *swig_obj[1] ;
23958
23959 if (!args) SWIG_fail;
23960 swig_obj[0] = args;
23961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23962 if (!SWIG_IsOK(res1)) {
23963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelAxis" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23964 }
23965 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23966 {
23967 PyThreadState* __tstate = wxPyBeginAllowThreads();
23968 result = (int)((wxMouseEvent const *)arg1)->GetWheelAxis();
23969 wxPyEndAllowThreads(__tstate);
23970 if (PyErr_Occurred()) SWIG_fail;
23971 }
23972 resultobj = SWIG_From_int(static_cast< int >(result));
23973 return resultobj;
23974 fail:
23975 return NULL;
23976 }
23977
23978
23979 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23980 PyObject *resultobj = 0;
23981 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23982 int result;
23983 void *argp1 = 0 ;
23984 int res1 = 0 ;
23985 PyObject *swig_obj[1] ;
23986
23987 if (!args) SWIG_fail;
23988 swig_obj[0] = args;
23989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23990 if (!SWIG_IsOK(res1)) {
23991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23992 }
23993 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23994 {
23995 PyThreadState* __tstate = wxPyBeginAllowThreads();
23996 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
23997 wxPyEndAllowThreads(__tstate);
23998 if (PyErr_Occurred()) SWIG_fail;
23999 }
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_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24008 PyObject *resultobj = 0;
24009 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24010 bool result;
24011 void *argp1 = 0 ;
24012 int res1 = 0 ;
24013 PyObject *swig_obj[1] ;
24014
24015 if (!args) SWIG_fail;
24016 swig_obj[0] = args;
24017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24018 if (!SWIG_IsOK(res1)) {
24019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24020 }
24021 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24022 {
24023 PyThreadState* __tstate = wxPyBeginAllowThreads();
24024 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
24025 wxPyEndAllowThreads(__tstate);
24026 if (PyErr_Occurred()) SWIG_fail;
24027 }
24028 {
24029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24030 }
24031 return resultobj;
24032 fail:
24033 return NULL;
24034 }
24035
24036
24037 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24038 PyObject *resultobj = 0;
24039 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24040 int arg2 ;
24041 void *argp1 = 0 ;
24042 int res1 = 0 ;
24043 int val2 ;
24044 int ecode2 = 0 ;
24045 PyObject *swig_obj[2] ;
24046
24047 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
24048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24049 if (!SWIG_IsOK(res1)) {
24050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24051 }
24052 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24053 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24054 if (!SWIG_IsOK(ecode2)) {
24055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
24056 }
24057 arg2 = static_cast< int >(val2);
24058 if (arg1) (arg1)->m_x = arg2;
24059
24060 resultobj = SWIG_Py_Void();
24061 return resultobj;
24062 fail:
24063 return NULL;
24064 }
24065
24066
24067 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24068 PyObject *resultobj = 0;
24069 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24070 int result;
24071 void *argp1 = 0 ;
24072 int res1 = 0 ;
24073 PyObject *swig_obj[1] ;
24074
24075 if (!args) SWIG_fail;
24076 swig_obj[0] = args;
24077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24078 if (!SWIG_IsOK(res1)) {
24079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24080 }
24081 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24082 result = (int) ((arg1)->m_x);
24083 resultobj = SWIG_From_int(static_cast< int >(result));
24084 return resultobj;
24085 fail:
24086 return NULL;
24087 }
24088
24089
24090 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24091 PyObject *resultobj = 0;
24092 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24093 int arg2 ;
24094 void *argp1 = 0 ;
24095 int res1 = 0 ;
24096 int val2 ;
24097 int ecode2 = 0 ;
24098 PyObject *swig_obj[2] ;
24099
24100 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24102 if (!SWIG_IsOK(res1)) {
24103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24104 }
24105 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24106 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24107 if (!SWIG_IsOK(ecode2)) {
24108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24109 }
24110 arg2 = static_cast< int >(val2);
24111 if (arg1) (arg1)->m_y = arg2;
24112
24113 resultobj = SWIG_Py_Void();
24114 return resultobj;
24115 fail:
24116 return NULL;
24117 }
24118
24119
24120 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24121 PyObject *resultobj = 0;
24122 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24123 int result;
24124 void *argp1 = 0 ;
24125 int res1 = 0 ;
24126 PyObject *swig_obj[1] ;
24127
24128 if (!args) SWIG_fail;
24129 swig_obj[0] = args;
24130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24131 if (!SWIG_IsOK(res1)) {
24132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24133 }
24134 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24135 result = (int) ((arg1)->m_y);
24136 resultobj = SWIG_From_int(static_cast< int >(result));
24137 return resultobj;
24138 fail:
24139 return NULL;
24140 }
24141
24142
24143 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24144 PyObject *resultobj = 0;
24145 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24146 bool arg2 ;
24147 void *argp1 = 0 ;
24148 int res1 = 0 ;
24149 bool val2 ;
24150 int ecode2 = 0 ;
24151 PyObject *swig_obj[2] ;
24152
24153 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24155 if (!SWIG_IsOK(res1)) {
24156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24157 }
24158 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24159 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24160 if (!SWIG_IsOK(ecode2)) {
24161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24162 }
24163 arg2 = static_cast< bool >(val2);
24164 if (arg1) (arg1)->m_leftDown = arg2;
24165
24166 resultobj = SWIG_Py_Void();
24167 return resultobj;
24168 fail:
24169 return NULL;
24170 }
24171
24172
24173 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24174 PyObject *resultobj = 0;
24175 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24176 bool result;
24177 void *argp1 = 0 ;
24178 int res1 = 0 ;
24179 PyObject *swig_obj[1] ;
24180
24181 if (!args) SWIG_fail;
24182 swig_obj[0] = args;
24183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24184 if (!SWIG_IsOK(res1)) {
24185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24186 }
24187 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24188 result = (bool) ((arg1)->m_leftDown);
24189 {
24190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24191 }
24192 return resultobj;
24193 fail:
24194 return NULL;
24195 }
24196
24197
24198 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24199 PyObject *resultobj = 0;
24200 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24201 bool arg2 ;
24202 void *argp1 = 0 ;
24203 int res1 = 0 ;
24204 bool val2 ;
24205 int ecode2 = 0 ;
24206 PyObject *swig_obj[2] ;
24207
24208 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24210 if (!SWIG_IsOK(res1)) {
24211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24212 }
24213 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24214 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24215 if (!SWIG_IsOK(ecode2)) {
24216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24217 }
24218 arg2 = static_cast< bool >(val2);
24219 if (arg1) (arg1)->m_middleDown = arg2;
24220
24221 resultobj = SWIG_Py_Void();
24222 return resultobj;
24223 fail:
24224 return NULL;
24225 }
24226
24227
24228 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24229 PyObject *resultobj = 0;
24230 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24231 bool result;
24232 void *argp1 = 0 ;
24233 int res1 = 0 ;
24234 PyObject *swig_obj[1] ;
24235
24236 if (!args) SWIG_fail;
24237 swig_obj[0] = args;
24238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24239 if (!SWIG_IsOK(res1)) {
24240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24241 }
24242 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24243 result = (bool) ((arg1)->m_middleDown);
24244 {
24245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24246 }
24247 return resultobj;
24248 fail:
24249 return NULL;
24250 }
24251
24252
24253 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24254 PyObject *resultobj = 0;
24255 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24256 bool arg2 ;
24257 void *argp1 = 0 ;
24258 int res1 = 0 ;
24259 bool val2 ;
24260 int ecode2 = 0 ;
24261 PyObject *swig_obj[2] ;
24262
24263 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24265 if (!SWIG_IsOK(res1)) {
24266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24267 }
24268 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24269 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24270 if (!SWIG_IsOK(ecode2)) {
24271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24272 }
24273 arg2 = static_cast< bool >(val2);
24274 if (arg1) (arg1)->m_rightDown = arg2;
24275
24276 resultobj = SWIG_Py_Void();
24277 return resultobj;
24278 fail:
24279 return NULL;
24280 }
24281
24282
24283 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24284 PyObject *resultobj = 0;
24285 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24286 bool result;
24287 void *argp1 = 0 ;
24288 int res1 = 0 ;
24289 PyObject *swig_obj[1] ;
24290
24291 if (!args) SWIG_fail;
24292 swig_obj[0] = args;
24293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24294 if (!SWIG_IsOK(res1)) {
24295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24296 }
24297 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24298 result = (bool) ((arg1)->m_rightDown);
24299 {
24300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24301 }
24302 return resultobj;
24303 fail:
24304 return NULL;
24305 }
24306
24307
24308 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24309 PyObject *resultobj = 0;
24310 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24311 bool arg2 ;
24312 void *argp1 = 0 ;
24313 int res1 = 0 ;
24314 bool val2 ;
24315 int ecode2 = 0 ;
24316 PyObject *swig_obj[2] ;
24317
24318 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24320 if (!SWIG_IsOK(res1)) {
24321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24322 }
24323 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24324 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24325 if (!SWIG_IsOK(ecode2)) {
24326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24327 }
24328 arg2 = static_cast< bool >(val2);
24329 if (arg1) (arg1)->m_controlDown = arg2;
24330
24331 resultobj = SWIG_Py_Void();
24332 return resultobj;
24333 fail:
24334 return NULL;
24335 }
24336
24337
24338 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24339 PyObject *resultobj = 0;
24340 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24341 bool result;
24342 void *argp1 = 0 ;
24343 int res1 = 0 ;
24344 PyObject *swig_obj[1] ;
24345
24346 if (!args) SWIG_fail;
24347 swig_obj[0] = args;
24348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24349 if (!SWIG_IsOK(res1)) {
24350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24351 }
24352 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24353 result = (bool) ((arg1)->m_controlDown);
24354 {
24355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24356 }
24357 return resultobj;
24358 fail:
24359 return NULL;
24360 }
24361
24362
24363 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24364 PyObject *resultobj = 0;
24365 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24366 bool arg2 ;
24367 void *argp1 = 0 ;
24368 int res1 = 0 ;
24369 bool val2 ;
24370 int ecode2 = 0 ;
24371 PyObject *swig_obj[2] ;
24372
24373 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24375 if (!SWIG_IsOK(res1)) {
24376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24377 }
24378 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24379 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24380 if (!SWIG_IsOK(ecode2)) {
24381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24382 }
24383 arg2 = static_cast< bool >(val2);
24384 if (arg1) (arg1)->m_shiftDown = arg2;
24385
24386 resultobj = SWIG_Py_Void();
24387 return resultobj;
24388 fail:
24389 return NULL;
24390 }
24391
24392
24393 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24394 PyObject *resultobj = 0;
24395 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24396 bool result;
24397 void *argp1 = 0 ;
24398 int res1 = 0 ;
24399 PyObject *swig_obj[1] ;
24400
24401 if (!args) SWIG_fail;
24402 swig_obj[0] = args;
24403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24404 if (!SWIG_IsOK(res1)) {
24405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24406 }
24407 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24408 result = (bool) ((arg1)->m_shiftDown);
24409 {
24410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24411 }
24412 return resultobj;
24413 fail:
24414 return NULL;
24415 }
24416
24417
24418 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24419 PyObject *resultobj = 0;
24420 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24421 bool arg2 ;
24422 void *argp1 = 0 ;
24423 int res1 = 0 ;
24424 bool val2 ;
24425 int ecode2 = 0 ;
24426 PyObject *swig_obj[2] ;
24427
24428 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24430 if (!SWIG_IsOK(res1)) {
24431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24432 }
24433 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24434 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24435 if (!SWIG_IsOK(ecode2)) {
24436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24437 }
24438 arg2 = static_cast< bool >(val2);
24439 if (arg1) (arg1)->m_altDown = arg2;
24440
24441 resultobj = SWIG_Py_Void();
24442 return resultobj;
24443 fail:
24444 return NULL;
24445 }
24446
24447
24448 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24449 PyObject *resultobj = 0;
24450 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24451 bool result;
24452 void *argp1 = 0 ;
24453 int res1 = 0 ;
24454 PyObject *swig_obj[1] ;
24455
24456 if (!args) SWIG_fail;
24457 swig_obj[0] = args;
24458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24459 if (!SWIG_IsOK(res1)) {
24460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24461 }
24462 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24463 result = (bool) ((arg1)->m_altDown);
24464 {
24465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24466 }
24467 return resultobj;
24468 fail:
24469 return NULL;
24470 }
24471
24472
24473 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24474 PyObject *resultobj = 0;
24475 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24476 bool arg2 ;
24477 void *argp1 = 0 ;
24478 int res1 = 0 ;
24479 bool val2 ;
24480 int ecode2 = 0 ;
24481 PyObject *swig_obj[2] ;
24482
24483 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24485 if (!SWIG_IsOK(res1)) {
24486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24487 }
24488 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24489 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24490 if (!SWIG_IsOK(ecode2)) {
24491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24492 }
24493 arg2 = static_cast< bool >(val2);
24494 if (arg1) (arg1)->m_metaDown = arg2;
24495
24496 resultobj = SWIG_Py_Void();
24497 return resultobj;
24498 fail:
24499 return NULL;
24500 }
24501
24502
24503 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24504 PyObject *resultobj = 0;
24505 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24506 bool result;
24507 void *argp1 = 0 ;
24508 int res1 = 0 ;
24509 PyObject *swig_obj[1] ;
24510
24511 if (!args) SWIG_fail;
24512 swig_obj[0] = args;
24513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24514 if (!SWIG_IsOK(res1)) {
24515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24516 }
24517 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24518 result = (bool) ((arg1)->m_metaDown);
24519 {
24520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24521 }
24522 return resultobj;
24523 fail:
24524 return NULL;
24525 }
24526
24527
24528 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24529 PyObject *resultobj = 0;
24530 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24531 int arg2 ;
24532 void *argp1 = 0 ;
24533 int res1 = 0 ;
24534 int val2 ;
24535 int ecode2 = 0 ;
24536 PyObject *swig_obj[2] ;
24537
24538 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24540 if (!SWIG_IsOK(res1)) {
24541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24542 }
24543 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24544 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24545 if (!SWIG_IsOK(ecode2)) {
24546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24547 }
24548 arg2 = static_cast< int >(val2);
24549 if (arg1) (arg1)->m_wheelRotation = arg2;
24550
24551 resultobj = SWIG_Py_Void();
24552 return resultobj;
24553 fail:
24554 return NULL;
24555 }
24556
24557
24558 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24559 PyObject *resultobj = 0;
24560 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24561 int result;
24562 void *argp1 = 0 ;
24563 int res1 = 0 ;
24564 PyObject *swig_obj[1] ;
24565
24566 if (!args) SWIG_fail;
24567 swig_obj[0] = args;
24568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24569 if (!SWIG_IsOK(res1)) {
24570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24571 }
24572 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24573 result = (int) ((arg1)->m_wheelRotation);
24574 resultobj = SWIG_From_int(static_cast< int >(result));
24575 return resultobj;
24576 fail:
24577 return NULL;
24578 }
24579
24580
24581 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24582 PyObject *resultobj = 0;
24583 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24584 int arg2 ;
24585 void *argp1 = 0 ;
24586 int res1 = 0 ;
24587 int val2 ;
24588 int ecode2 = 0 ;
24589 PyObject *swig_obj[2] ;
24590
24591 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24593 if (!SWIG_IsOK(res1)) {
24594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24595 }
24596 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24597 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24598 if (!SWIG_IsOK(ecode2)) {
24599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24600 }
24601 arg2 = static_cast< int >(val2);
24602 if (arg1) (arg1)->m_wheelDelta = arg2;
24603
24604 resultobj = SWIG_Py_Void();
24605 return resultobj;
24606 fail:
24607 return NULL;
24608 }
24609
24610
24611 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24612 PyObject *resultobj = 0;
24613 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24614 int result;
24615 void *argp1 = 0 ;
24616 int res1 = 0 ;
24617 PyObject *swig_obj[1] ;
24618
24619 if (!args) SWIG_fail;
24620 swig_obj[0] = args;
24621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24622 if (!SWIG_IsOK(res1)) {
24623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24624 }
24625 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24626 result = (int) ((arg1)->m_wheelDelta);
24627 resultobj = SWIG_From_int(static_cast< int >(result));
24628 return resultobj;
24629 fail:
24630 return NULL;
24631 }
24632
24633
24634 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24635 PyObject *resultobj = 0;
24636 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24637 int arg2 ;
24638 void *argp1 = 0 ;
24639 int res1 = 0 ;
24640 int val2 ;
24641 int ecode2 = 0 ;
24642 PyObject *swig_obj[2] ;
24643
24644 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24646 if (!SWIG_IsOK(res1)) {
24647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24648 }
24649 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24650 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24651 if (!SWIG_IsOK(ecode2)) {
24652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24653 }
24654 arg2 = static_cast< int >(val2);
24655 if (arg1) (arg1)->m_linesPerAction = arg2;
24656
24657 resultobj = SWIG_Py_Void();
24658 return resultobj;
24659 fail:
24660 return NULL;
24661 }
24662
24663
24664 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24665 PyObject *resultobj = 0;
24666 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24667 int result;
24668 void *argp1 = 0 ;
24669 int res1 = 0 ;
24670 PyObject *swig_obj[1] ;
24671
24672 if (!args) SWIG_fail;
24673 swig_obj[0] = args;
24674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24675 if (!SWIG_IsOK(res1)) {
24676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24677 }
24678 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24679 result = (int) ((arg1)->m_linesPerAction);
24680 resultobj = SWIG_From_int(static_cast< int >(result));
24681 return resultobj;
24682 fail:
24683 return NULL;
24684 }
24685
24686
24687 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24688 PyObject *obj;
24689 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24690 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24691 return SWIG_Py_Void();
24692 }
24693
24694 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24695 return SWIG_Python_InitShadowInstance(args);
24696 }
24697
24698 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24699 PyObject *resultobj = 0;
24700 int arg1 = (int) 0 ;
24701 int arg2 = (int) 0 ;
24702 wxSetCursorEvent *result = 0 ;
24703 int val1 ;
24704 int ecode1 = 0 ;
24705 int val2 ;
24706 int ecode2 = 0 ;
24707 PyObject * obj0 = 0 ;
24708 PyObject * obj1 = 0 ;
24709 char * kwnames[] = {
24710 (char *) "x",(char *) "y", NULL
24711 };
24712
24713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24714 if (obj0) {
24715 ecode1 = SWIG_AsVal_int(obj0, &val1);
24716 if (!SWIG_IsOK(ecode1)) {
24717 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24718 }
24719 arg1 = static_cast< int >(val1);
24720 }
24721 if (obj1) {
24722 ecode2 = SWIG_AsVal_int(obj1, &val2);
24723 if (!SWIG_IsOK(ecode2)) {
24724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24725 }
24726 arg2 = static_cast< int >(val2);
24727 }
24728 {
24729 PyThreadState* __tstate = wxPyBeginAllowThreads();
24730 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24731 wxPyEndAllowThreads(__tstate);
24732 if (PyErr_Occurred()) SWIG_fail;
24733 }
24734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24735 return resultobj;
24736 fail:
24737 return NULL;
24738 }
24739
24740
24741 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24742 PyObject *resultobj = 0;
24743 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24744 int result;
24745 void *argp1 = 0 ;
24746 int res1 = 0 ;
24747 PyObject *swig_obj[1] ;
24748
24749 if (!args) SWIG_fail;
24750 swig_obj[0] = args;
24751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24752 if (!SWIG_IsOK(res1)) {
24753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24754 }
24755 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24756 {
24757 PyThreadState* __tstate = wxPyBeginAllowThreads();
24758 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24759 wxPyEndAllowThreads(__tstate);
24760 if (PyErr_Occurred()) SWIG_fail;
24761 }
24762 resultobj = SWIG_From_int(static_cast< int >(result));
24763 return resultobj;
24764 fail:
24765 return NULL;
24766 }
24767
24768
24769 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24770 PyObject *resultobj = 0;
24771 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24772 int result;
24773 void *argp1 = 0 ;
24774 int res1 = 0 ;
24775 PyObject *swig_obj[1] ;
24776
24777 if (!args) SWIG_fail;
24778 swig_obj[0] = args;
24779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24780 if (!SWIG_IsOK(res1)) {
24781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24782 }
24783 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24784 {
24785 PyThreadState* __tstate = wxPyBeginAllowThreads();
24786 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24787 wxPyEndAllowThreads(__tstate);
24788 if (PyErr_Occurred()) SWIG_fail;
24789 }
24790 resultobj = SWIG_From_int(static_cast< int >(result));
24791 return resultobj;
24792 fail:
24793 return NULL;
24794 }
24795
24796
24797 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24798 PyObject *resultobj = 0;
24799 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24800 wxCursor *arg2 = 0 ;
24801 void *argp1 = 0 ;
24802 int res1 = 0 ;
24803 void *argp2 = 0 ;
24804 int res2 = 0 ;
24805 PyObject * obj0 = 0 ;
24806 PyObject * obj1 = 0 ;
24807 char * kwnames[] = {
24808 (char *) "self",(char *) "cursor", NULL
24809 };
24810
24811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24813 if (!SWIG_IsOK(res1)) {
24814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24815 }
24816 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24817 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24818 if (!SWIG_IsOK(res2)) {
24819 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24820 }
24821 if (!argp2) {
24822 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24823 }
24824 arg2 = reinterpret_cast< wxCursor * >(argp2);
24825 {
24826 PyThreadState* __tstate = wxPyBeginAllowThreads();
24827 (arg1)->SetCursor((wxCursor const &)*arg2);
24828 wxPyEndAllowThreads(__tstate);
24829 if (PyErr_Occurred()) SWIG_fail;
24830 }
24831 resultobj = SWIG_Py_Void();
24832 return resultobj;
24833 fail:
24834 return NULL;
24835 }
24836
24837
24838 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24839 PyObject *resultobj = 0;
24840 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24841 wxCursor *result = 0 ;
24842 void *argp1 = 0 ;
24843 int res1 = 0 ;
24844 PyObject *swig_obj[1] ;
24845
24846 if (!args) SWIG_fail;
24847 swig_obj[0] = args;
24848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24849 if (!SWIG_IsOK(res1)) {
24850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24851 }
24852 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24853 {
24854 PyThreadState* __tstate = wxPyBeginAllowThreads();
24855 {
24856 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24857 result = (wxCursor *) &_result_ref;
24858 }
24859 wxPyEndAllowThreads(__tstate);
24860 if (PyErr_Occurred()) SWIG_fail;
24861 }
24862 {
24863 wxCursor* resultptr = new wxCursor(*result);
24864 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24865 }
24866 return resultobj;
24867 fail:
24868 return NULL;
24869 }
24870
24871
24872 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24873 PyObject *resultobj = 0;
24874 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24875 bool result;
24876 void *argp1 = 0 ;
24877 int res1 = 0 ;
24878 PyObject *swig_obj[1] ;
24879
24880 if (!args) SWIG_fail;
24881 swig_obj[0] = args;
24882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24883 if (!SWIG_IsOK(res1)) {
24884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24885 }
24886 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24887 {
24888 PyThreadState* __tstate = wxPyBeginAllowThreads();
24889 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24890 wxPyEndAllowThreads(__tstate);
24891 if (PyErr_Occurred()) SWIG_fail;
24892 }
24893 {
24894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24895 }
24896 return resultobj;
24897 fail:
24898 return NULL;
24899 }
24900
24901
24902 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24903 PyObject *obj;
24904 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24905 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24906 return SWIG_Py_Void();
24907 }
24908
24909 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24910 return SWIG_Python_InitShadowInstance(args);
24911 }
24912
24913 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24914 PyObject *resultobj = 0;
24915 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24916 wxKeyEvent *result = 0 ;
24917 int val1 ;
24918 int ecode1 = 0 ;
24919 PyObject * obj0 = 0 ;
24920 char * kwnames[] = {
24921 (char *) "eventType", NULL
24922 };
24923
24924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24925 if (obj0) {
24926 ecode1 = SWIG_AsVal_int(obj0, &val1);
24927 if (!SWIG_IsOK(ecode1)) {
24928 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24929 }
24930 arg1 = static_cast< wxEventType >(val1);
24931 }
24932 {
24933 PyThreadState* __tstate = wxPyBeginAllowThreads();
24934 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24935 wxPyEndAllowThreads(__tstate);
24936 if (PyErr_Occurred()) SWIG_fail;
24937 }
24938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24939 return resultobj;
24940 fail:
24941 return NULL;
24942 }
24943
24944
24945 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24946 PyObject *resultobj = 0;
24947 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24948 int result;
24949 void *argp1 = 0 ;
24950 int res1 = 0 ;
24951 PyObject *swig_obj[1] ;
24952
24953 if (!args) SWIG_fail;
24954 swig_obj[0] = args;
24955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24956 if (!SWIG_IsOK(res1)) {
24957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24958 }
24959 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24960 {
24961 PyThreadState* __tstate = wxPyBeginAllowThreads();
24962 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24963 wxPyEndAllowThreads(__tstate);
24964 if (PyErr_Occurred()) SWIG_fail;
24965 }
24966 resultobj = SWIG_From_int(static_cast< int >(result));
24967 return resultobj;
24968 fail:
24969 return NULL;
24970 }
24971
24972
24973 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24974 PyObject *resultobj = 0;
24975 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24976 bool result;
24977 void *argp1 = 0 ;
24978 int res1 = 0 ;
24979 PyObject *swig_obj[1] ;
24980
24981 if (!args) SWIG_fail;
24982 swig_obj[0] = args;
24983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24984 if (!SWIG_IsOK(res1)) {
24985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24986 }
24987 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24988 {
24989 PyThreadState* __tstate = wxPyBeginAllowThreads();
24990 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
24991 wxPyEndAllowThreads(__tstate);
24992 if (PyErr_Occurred()) SWIG_fail;
24993 }
24994 {
24995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24996 }
24997 return resultobj;
24998 fail:
24999 return NULL;
25000 }
25001
25002
25003 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25004 PyObject *resultobj = 0;
25005 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25006 bool result;
25007 void *argp1 = 0 ;
25008 int res1 = 0 ;
25009 PyObject *swig_obj[1] ;
25010
25011 if (!args) SWIG_fail;
25012 swig_obj[0] = args;
25013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25014 if (!SWIG_IsOK(res1)) {
25015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25016 }
25017 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25018 {
25019 PyThreadState* __tstate = wxPyBeginAllowThreads();
25020 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
25021 wxPyEndAllowThreads(__tstate);
25022 if (PyErr_Occurred()) SWIG_fail;
25023 }
25024 {
25025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25026 }
25027 return resultobj;
25028 fail:
25029 return NULL;
25030 }
25031
25032
25033 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25034 PyObject *resultobj = 0;
25035 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25036 bool result;
25037 void *argp1 = 0 ;
25038 int res1 = 0 ;
25039 PyObject *swig_obj[1] ;
25040
25041 if (!args) SWIG_fail;
25042 swig_obj[0] = args;
25043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25044 if (!SWIG_IsOK(res1)) {
25045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25046 }
25047 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25048 {
25049 PyThreadState* __tstate = wxPyBeginAllowThreads();
25050 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
25051 wxPyEndAllowThreads(__tstate);
25052 if (PyErr_Occurred()) SWIG_fail;
25053 }
25054 {
25055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25056 }
25057 return resultobj;
25058 fail:
25059 return NULL;
25060 }
25061
25062
25063 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25064 PyObject *resultobj = 0;
25065 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25066 bool result;
25067 void *argp1 = 0 ;
25068 int res1 = 0 ;
25069 PyObject *swig_obj[1] ;
25070
25071 if (!args) SWIG_fail;
25072 swig_obj[0] = args;
25073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25074 if (!SWIG_IsOK(res1)) {
25075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25076 }
25077 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25078 {
25079 PyThreadState* __tstate = wxPyBeginAllowThreads();
25080 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
25081 wxPyEndAllowThreads(__tstate);
25082 if (PyErr_Occurred()) SWIG_fail;
25083 }
25084 {
25085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25086 }
25087 return resultobj;
25088 fail:
25089 return NULL;
25090 }
25091
25092
25093 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25094 PyObject *resultobj = 0;
25095 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25096 bool result;
25097 void *argp1 = 0 ;
25098 int res1 = 0 ;
25099 PyObject *swig_obj[1] ;
25100
25101 if (!args) SWIG_fail;
25102 swig_obj[0] = args;
25103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25104 if (!SWIG_IsOK(res1)) {
25105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25106 }
25107 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25108 {
25109 PyThreadState* __tstate = wxPyBeginAllowThreads();
25110 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25111 wxPyEndAllowThreads(__tstate);
25112 if (PyErr_Occurred()) SWIG_fail;
25113 }
25114 {
25115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25116 }
25117 return resultobj;
25118 fail:
25119 return NULL;
25120 }
25121
25122
25123 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25124 PyObject *resultobj = 0;
25125 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25126 bool result;
25127 void *argp1 = 0 ;
25128 int res1 = 0 ;
25129 PyObject *swig_obj[1] ;
25130
25131 if (!args) SWIG_fail;
25132 swig_obj[0] = args;
25133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25134 if (!SWIG_IsOK(res1)) {
25135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25136 }
25137 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25138 {
25139 PyThreadState* __tstate = wxPyBeginAllowThreads();
25140 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25141 wxPyEndAllowThreads(__tstate);
25142 if (PyErr_Occurred()) SWIG_fail;
25143 }
25144 {
25145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25146 }
25147 return resultobj;
25148 fail:
25149 return NULL;
25150 }
25151
25152
25153 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25154 PyObject *resultobj = 0;
25155 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25156 int result;
25157 void *argp1 = 0 ;
25158 int res1 = 0 ;
25159 PyObject *swig_obj[1] ;
25160
25161 if (!args) SWIG_fail;
25162 swig_obj[0] = args;
25163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25164 if (!SWIG_IsOK(res1)) {
25165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25166 }
25167 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25168 {
25169 PyThreadState* __tstate = wxPyBeginAllowThreads();
25170 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25171 wxPyEndAllowThreads(__tstate);
25172 if (PyErr_Occurred()) SWIG_fail;
25173 }
25174 resultobj = SWIG_From_int(static_cast< int >(result));
25175 return resultobj;
25176 fail:
25177 return NULL;
25178 }
25179
25180
25181 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25182 PyObject *resultobj = 0;
25183 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25184 int result;
25185 void *argp1 = 0 ;
25186 int res1 = 0 ;
25187 PyObject *swig_obj[1] ;
25188
25189 if (!args) SWIG_fail;
25190 swig_obj[0] = args;
25191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25192 if (!SWIG_IsOK(res1)) {
25193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25194 }
25195 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25196 {
25197 PyThreadState* __tstate = wxPyBeginAllowThreads();
25198 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25199 wxPyEndAllowThreads(__tstate);
25200 if (PyErr_Occurred()) SWIG_fail;
25201 }
25202 resultobj = SWIG_From_int(static_cast< int >(result));
25203 return resultobj;
25204 fail:
25205 return NULL;
25206 }
25207
25208
25209 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25210 PyObject *resultobj = 0;
25211 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25212 int arg2 ;
25213 void *argp1 = 0 ;
25214 int res1 = 0 ;
25215 int val2 ;
25216 int ecode2 = 0 ;
25217 PyObject * obj0 = 0 ;
25218 PyObject * obj1 = 0 ;
25219 char * kwnames[] = {
25220 (char *) "self",(char *) "uniChar", NULL
25221 };
25222
25223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25225 if (!SWIG_IsOK(res1)) {
25226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25227 }
25228 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25229 ecode2 = SWIG_AsVal_int(obj1, &val2);
25230 if (!SWIG_IsOK(ecode2)) {
25231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25232 }
25233 arg2 = static_cast< int >(val2);
25234 {
25235 PyThreadState* __tstate = wxPyBeginAllowThreads();
25236 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25237 wxPyEndAllowThreads(__tstate);
25238 if (PyErr_Occurred()) SWIG_fail;
25239 }
25240 resultobj = SWIG_Py_Void();
25241 return resultobj;
25242 fail:
25243 return NULL;
25244 }
25245
25246
25247 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25248 PyObject *resultobj = 0;
25249 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25250 unsigned int result;
25251 void *argp1 = 0 ;
25252 int res1 = 0 ;
25253 PyObject *swig_obj[1] ;
25254
25255 if (!args) SWIG_fail;
25256 swig_obj[0] = args;
25257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25258 if (!SWIG_IsOK(res1)) {
25259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25260 }
25261 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25262 {
25263 PyThreadState* __tstate = wxPyBeginAllowThreads();
25264 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25265 wxPyEndAllowThreads(__tstate);
25266 if (PyErr_Occurred()) SWIG_fail;
25267 }
25268 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25269 return resultobj;
25270 fail:
25271 return NULL;
25272 }
25273
25274
25275 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25276 PyObject *resultobj = 0;
25277 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25278 unsigned int result;
25279 void *argp1 = 0 ;
25280 int res1 = 0 ;
25281 PyObject *swig_obj[1] ;
25282
25283 if (!args) SWIG_fail;
25284 swig_obj[0] = args;
25285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25286 if (!SWIG_IsOK(res1)) {
25287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25288 }
25289 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25290 {
25291 PyThreadState* __tstate = wxPyBeginAllowThreads();
25292 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25293 wxPyEndAllowThreads(__tstate);
25294 if (PyErr_Occurred()) SWIG_fail;
25295 }
25296 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25297 return resultobj;
25298 fail:
25299 return NULL;
25300 }
25301
25302
25303 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25304 PyObject *resultobj = 0;
25305 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25306 wxPoint result;
25307 void *argp1 = 0 ;
25308 int res1 = 0 ;
25309 PyObject *swig_obj[1] ;
25310
25311 if (!args) SWIG_fail;
25312 swig_obj[0] = args;
25313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25314 if (!SWIG_IsOK(res1)) {
25315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25316 }
25317 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25318 {
25319 PyThreadState* __tstate = wxPyBeginAllowThreads();
25320 result = (arg1)->GetPosition();
25321 wxPyEndAllowThreads(__tstate);
25322 if (PyErr_Occurred()) SWIG_fail;
25323 }
25324 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25325 return resultobj;
25326 fail:
25327 return NULL;
25328 }
25329
25330
25331 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25332 PyObject *resultobj = 0;
25333 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25334 long *arg2 = (long *) 0 ;
25335 long *arg3 = (long *) 0 ;
25336 void *argp1 = 0 ;
25337 int res1 = 0 ;
25338 long temp2 ;
25339 int res2 = SWIG_TMPOBJ ;
25340 long temp3 ;
25341 int res3 = SWIG_TMPOBJ ;
25342 PyObject *swig_obj[1] ;
25343
25344 arg2 = &temp2;
25345 arg3 = &temp3;
25346 if (!args) SWIG_fail;
25347 swig_obj[0] = args;
25348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25349 if (!SWIG_IsOK(res1)) {
25350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25351 }
25352 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25353 {
25354 PyThreadState* __tstate = wxPyBeginAllowThreads();
25355 (arg1)->GetPosition(arg2,arg3);
25356 wxPyEndAllowThreads(__tstate);
25357 if (PyErr_Occurred()) SWIG_fail;
25358 }
25359 resultobj = SWIG_Py_Void();
25360 if (SWIG_IsTmpObj(res2)) {
25361 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25362 } else {
25363 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25364 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25365 }
25366 if (SWIG_IsTmpObj(res3)) {
25367 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25368 } else {
25369 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25370 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25371 }
25372 return resultobj;
25373 fail:
25374 return NULL;
25375 }
25376
25377
25378 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25379 PyObject *resultobj = 0;
25380 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25381 int result;
25382 void *argp1 = 0 ;
25383 int res1 = 0 ;
25384 PyObject *swig_obj[1] ;
25385
25386 if (!args) SWIG_fail;
25387 swig_obj[0] = args;
25388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25389 if (!SWIG_IsOK(res1)) {
25390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25391 }
25392 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25393 {
25394 PyThreadState* __tstate = wxPyBeginAllowThreads();
25395 result = (int)((wxKeyEvent const *)arg1)->GetX();
25396 wxPyEndAllowThreads(__tstate);
25397 if (PyErr_Occurred()) SWIG_fail;
25398 }
25399 resultobj = SWIG_From_int(static_cast< int >(result));
25400 return resultobj;
25401 fail:
25402 return NULL;
25403 }
25404
25405
25406 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25407 PyObject *resultobj = 0;
25408 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25409 int result;
25410 void *argp1 = 0 ;
25411 int res1 = 0 ;
25412 PyObject *swig_obj[1] ;
25413
25414 if (!args) SWIG_fail;
25415 swig_obj[0] = args;
25416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25417 if (!SWIG_IsOK(res1)) {
25418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25419 }
25420 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25421 {
25422 PyThreadState* __tstate = wxPyBeginAllowThreads();
25423 result = (int)((wxKeyEvent const *)arg1)->GetY();
25424 wxPyEndAllowThreads(__tstate);
25425 if (PyErr_Occurred()) SWIG_fail;
25426 }
25427 resultobj = SWIG_From_int(static_cast< int >(result));
25428 return resultobj;
25429 fail:
25430 return NULL;
25431 }
25432
25433
25434 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25435 PyObject *resultobj = 0;
25436 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25437 int arg2 ;
25438 void *argp1 = 0 ;
25439 int res1 = 0 ;
25440 int val2 ;
25441 int ecode2 = 0 ;
25442 PyObject *swig_obj[2] ;
25443
25444 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25446 if (!SWIG_IsOK(res1)) {
25447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25448 }
25449 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25450 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25451 if (!SWIG_IsOK(ecode2)) {
25452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25453 }
25454 arg2 = static_cast< int >(val2);
25455 if (arg1) (arg1)->m_x = arg2;
25456
25457 resultobj = SWIG_Py_Void();
25458 return resultobj;
25459 fail:
25460 return NULL;
25461 }
25462
25463
25464 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25465 PyObject *resultobj = 0;
25466 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25467 int result;
25468 void *argp1 = 0 ;
25469 int res1 = 0 ;
25470 PyObject *swig_obj[1] ;
25471
25472 if (!args) SWIG_fail;
25473 swig_obj[0] = args;
25474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25475 if (!SWIG_IsOK(res1)) {
25476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25477 }
25478 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25479 result = (int) ((arg1)->m_x);
25480 resultobj = SWIG_From_int(static_cast< int >(result));
25481 return resultobj;
25482 fail:
25483 return NULL;
25484 }
25485
25486
25487 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25488 PyObject *resultobj = 0;
25489 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25490 int arg2 ;
25491 void *argp1 = 0 ;
25492 int res1 = 0 ;
25493 int val2 ;
25494 int ecode2 = 0 ;
25495 PyObject *swig_obj[2] ;
25496
25497 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25499 if (!SWIG_IsOK(res1)) {
25500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25501 }
25502 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25503 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25504 if (!SWIG_IsOK(ecode2)) {
25505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25506 }
25507 arg2 = static_cast< int >(val2);
25508 if (arg1) (arg1)->m_y = arg2;
25509
25510 resultobj = SWIG_Py_Void();
25511 return resultobj;
25512 fail:
25513 return NULL;
25514 }
25515
25516
25517 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25518 PyObject *resultobj = 0;
25519 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25520 int result;
25521 void *argp1 = 0 ;
25522 int res1 = 0 ;
25523 PyObject *swig_obj[1] ;
25524
25525 if (!args) SWIG_fail;
25526 swig_obj[0] = args;
25527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25528 if (!SWIG_IsOK(res1)) {
25529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25530 }
25531 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25532 result = (int) ((arg1)->m_y);
25533 resultobj = SWIG_From_int(static_cast< int >(result));
25534 return resultobj;
25535 fail:
25536 return NULL;
25537 }
25538
25539
25540 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25541 PyObject *resultobj = 0;
25542 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25543 long arg2 ;
25544 void *argp1 = 0 ;
25545 int res1 = 0 ;
25546 long val2 ;
25547 int ecode2 = 0 ;
25548 PyObject *swig_obj[2] ;
25549
25550 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25552 if (!SWIG_IsOK(res1)) {
25553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25554 }
25555 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25556 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25557 if (!SWIG_IsOK(ecode2)) {
25558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25559 }
25560 arg2 = static_cast< long >(val2);
25561 if (arg1) (arg1)->m_keyCode = arg2;
25562
25563 resultobj = SWIG_Py_Void();
25564 return resultobj;
25565 fail:
25566 return NULL;
25567 }
25568
25569
25570 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25571 PyObject *resultobj = 0;
25572 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25573 long result;
25574 void *argp1 = 0 ;
25575 int res1 = 0 ;
25576 PyObject *swig_obj[1] ;
25577
25578 if (!args) SWIG_fail;
25579 swig_obj[0] = args;
25580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25581 if (!SWIG_IsOK(res1)) {
25582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25583 }
25584 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25585 result = (long) ((arg1)->m_keyCode);
25586 resultobj = SWIG_From_long(static_cast< long >(result));
25587 return resultobj;
25588 fail:
25589 return NULL;
25590 }
25591
25592
25593 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25594 PyObject *resultobj = 0;
25595 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25596 bool arg2 ;
25597 void *argp1 = 0 ;
25598 int res1 = 0 ;
25599 bool val2 ;
25600 int ecode2 = 0 ;
25601 PyObject *swig_obj[2] ;
25602
25603 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25605 if (!SWIG_IsOK(res1)) {
25606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25607 }
25608 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25609 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25610 if (!SWIG_IsOK(ecode2)) {
25611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25612 }
25613 arg2 = static_cast< bool >(val2);
25614 if (arg1) (arg1)->m_controlDown = arg2;
25615
25616 resultobj = SWIG_Py_Void();
25617 return resultobj;
25618 fail:
25619 return NULL;
25620 }
25621
25622
25623 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25624 PyObject *resultobj = 0;
25625 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25626 bool result;
25627 void *argp1 = 0 ;
25628 int res1 = 0 ;
25629 PyObject *swig_obj[1] ;
25630
25631 if (!args) SWIG_fail;
25632 swig_obj[0] = args;
25633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25634 if (!SWIG_IsOK(res1)) {
25635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25636 }
25637 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25638 result = (bool) ((arg1)->m_controlDown);
25639 {
25640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25641 }
25642 return resultobj;
25643 fail:
25644 return NULL;
25645 }
25646
25647
25648 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25649 PyObject *resultobj = 0;
25650 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25651 bool arg2 ;
25652 void *argp1 = 0 ;
25653 int res1 = 0 ;
25654 bool val2 ;
25655 int ecode2 = 0 ;
25656 PyObject *swig_obj[2] ;
25657
25658 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25660 if (!SWIG_IsOK(res1)) {
25661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25662 }
25663 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25664 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25665 if (!SWIG_IsOK(ecode2)) {
25666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25667 }
25668 arg2 = static_cast< bool >(val2);
25669 if (arg1) (arg1)->m_shiftDown = arg2;
25670
25671 resultobj = SWIG_Py_Void();
25672 return resultobj;
25673 fail:
25674 return NULL;
25675 }
25676
25677
25678 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25679 PyObject *resultobj = 0;
25680 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25681 bool result;
25682 void *argp1 = 0 ;
25683 int res1 = 0 ;
25684 PyObject *swig_obj[1] ;
25685
25686 if (!args) SWIG_fail;
25687 swig_obj[0] = args;
25688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25689 if (!SWIG_IsOK(res1)) {
25690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25691 }
25692 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25693 result = (bool) ((arg1)->m_shiftDown);
25694 {
25695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25696 }
25697 return resultobj;
25698 fail:
25699 return NULL;
25700 }
25701
25702
25703 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25704 PyObject *resultobj = 0;
25705 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25706 bool arg2 ;
25707 void *argp1 = 0 ;
25708 int res1 = 0 ;
25709 bool val2 ;
25710 int ecode2 = 0 ;
25711 PyObject *swig_obj[2] ;
25712
25713 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25715 if (!SWIG_IsOK(res1)) {
25716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25717 }
25718 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25719 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25720 if (!SWIG_IsOK(ecode2)) {
25721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25722 }
25723 arg2 = static_cast< bool >(val2);
25724 if (arg1) (arg1)->m_altDown = arg2;
25725
25726 resultobj = SWIG_Py_Void();
25727 return resultobj;
25728 fail:
25729 return NULL;
25730 }
25731
25732
25733 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25734 PyObject *resultobj = 0;
25735 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25736 bool result;
25737 void *argp1 = 0 ;
25738 int res1 = 0 ;
25739 PyObject *swig_obj[1] ;
25740
25741 if (!args) SWIG_fail;
25742 swig_obj[0] = args;
25743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25744 if (!SWIG_IsOK(res1)) {
25745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25746 }
25747 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25748 result = (bool) ((arg1)->m_altDown);
25749 {
25750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25751 }
25752 return resultobj;
25753 fail:
25754 return NULL;
25755 }
25756
25757
25758 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25759 PyObject *resultobj = 0;
25760 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25761 bool arg2 ;
25762 void *argp1 = 0 ;
25763 int res1 = 0 ;
25764 bool val2 ;
25765 int ecode2 = 0 ;
25766 PyObject *swig_obj[2] ;
25767
25768 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25770 if (!SWIG_IsOK(res1)) {
25771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25772 }
25773 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25774 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25775 if (!SWIG_IsOK(ecode2)) {
25776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25777 }
25778 arg2 = static_cast< bool >(val2);
25779 if (arg1) (arg1)->m_metaDown = arg2;
25780
25781 resultobj = SWIG_Py_Void();
25782 return resultobj;
25783 fail:
25784 return NULL;
25785 }
25786
25787
25788 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25789 PyObject *resultobj = 0;
25790 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25791 bool result;
25792 void *argp1 = 0 ;
25793 int res1 = 0 ;
25794 PyObject *swig_obj[1] ;
25795
25796 if (!args) SWIG_fail;
25797 swig_obj[0] = args;
25798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25799 if (!SWIG_IsOK(res1)) {
25800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25801 }
25802 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25803 result = (bool) ((arg1)->m_metaDown);
25804 {
25805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25806 }
25807 return resultobj;
25808 fail:
25809 return NULL;
25810 }
25811
25812
25813 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25814 PyObject *resultobj = 0;
25815 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25816 bool arg2 ;
25817 void *argp1 = 0 ;
25818 int res1 = 0 ;
25819 bool val2 ;
25820 int ecode2 = 0 ;
25821 PyObject *swig_obj[2] ;
25822
25823 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25825 if (!SWIG_IsOK(res1)) {
25826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25827 }
25828 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25829 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25830 if (!SWIG_IsOK(ecode2)) {
25831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25832 }
25833 arg2 = static_cast< bool >(val2);
25834 if (arg1) (arg1)->m_scanCode = arg2;
25835
25836 resultobj = SWIG_Py_Void();
25837 return resultobj;
25838 fail:
25839 return NULL;
25840 }
25841
25842
25843 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25844 PyObject *resultobj = 0;
25845 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25846 bool result;
25847 void *argp1 = 0 ;
25848 int res1 = 0 ;
25849 PyObject *swig_obj[1] ;
25850
25851 if (!args) SWIG_fail;
25852 swig_obj[0] = args;
25853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25854 if (!SWIG_IsOK(res1)) {
25855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25856 }
25857 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25858 result = (bool) ((arg1)->m_scanCode);
25859 {
25860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25861 }
25862 return resultobj;
25863 fail:
25864 return NULL;
25865 }
25866
25867
25868 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25869 PyObject *resultobj = 0;
25870 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25871 unsigned int arg2 ;
25872 void *argp1 = 0 ;
25873 int res1 = 0 ;
25874 unsigned int val2 ;
25875 int ecode2 = 0 ;
25876 PyObject *swig_obj[2] ;
25877
25878 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25880 if (!SWIG_IsOK(res1)) {
25881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25882 }
25883 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25884 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25885 if (!SWIG_IsOK(ecode2)) {
25886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25887 }
25888 arg2 = static_cast< unsigned int >(val2);
25889 if (arg1) (arg1)->m_rawCode = arg2;
25890
25891 resultobj = SWIG_Py_Void();
25892 return resultobj;
25893 fail:
25894 return NULL;
25895 }
25896
25897
25898 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25899 PyObject *resultobj = 0;
25900 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25901 unsigned int result;
25902 void *argp1 = 0 ;
25903 int res1 = 0 ;
25904 PyObject *swig_obj[1] ;
25905
25906 if (!args) SWIG_fail;
25907 swig_obj[0] = args;
25908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25909 if (!SWIG_IsOK(res1)) {
25910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25911 }
25912 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25913 result = (unsigned int) ((arg1)->m_rawCode);
25914 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25915 return resultobj;
25916 fail:
25917 return NULL;
25918 }
25919
25920
25921 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25922 PyObject *resultobj = 0;
25923 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25924 unsigned int arg2 ;
25925 void *argp1 = 0 ;
25926 int res1 = 0 ;
25927 unsigned int val2 ;
25928 int ecode2 = 0 ;
25929 PyObject *swig_obj[2] ;
25930
25931 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25933 if (!SWIG_IsOK(res1)) {
25934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25935 }
25936 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25937 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25938 if (!SWIG_IsOK(ecode2)) {
25939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25940 }
25941 arg2 = static_cast< unsigned int >(val2);
25942 if (arg1) (arg1)->m_rawFlags = arg2;
25943
25944 resultobj = SWIG_Py_Void();
25945 return resultobj;
25946 fail:
25947 return NULL;
25948 }
25949
25950
25951 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25952 PyObject *resultobj = 0;
25953 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25954 unsigned int result;
25955 void *argp1 = 0 ;
25956 int res1 = 0 ;
25957 PyObject *swig_obj[1] ;
25958
25959 if (!args) SWIG_fail;
25960 swig_obj[0] = args;
25961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25962 if (!SWIG_IsOK(res1)) {
25963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25964 }
25965 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25966 result = (unsigned int) ((arg1)->m_rawFlags);
25967 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25968 return resultobj;
25969 fail:
25970 return NULL;
25971 }
25972
25973
25974 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25975 PyObject *obj;
25976 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25977 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25978 return SWIG_Py_Void();
25979 }
25980
25981 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25982 return SWIG_Python_InitShadowInstance(args);
25983 }
25984
25985 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25986 PyObject *resultobj = 0;
25987 wxSize const &arg1_defvalue = wxDefaultSize ;
25988 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
25989 int arg2 = (int) 0 ;
25990 wxSizeEvent *result = 0 ;
25991 wxSize temp1 ;
25992 int val2 ;
25993 int ecode2 = 0 ;
25994 PyObject * obj0 = 0 ;
25995 PyObject * obj1 = 0 ;
25996 char * kwnames[] = {
25997 (char *) "sz",(char *) "winid", NULL
25998 };
25999
26000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26001 if (obj0) {
26002 {
26003 arg1 = &temp1;
26004 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
26005 }
26006 }
26007 if (obj1) {
26008 ecode2 = SWIG_AsVal_int(obj1, &val2);
26009 if (!SWIG_IsOK(ecode2)) {
26010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
26011 }
26012 arg2 = static_cast< int >(val2);
26013 }
26014 {
26015 PyThreadState* __tstate = wxPyBeginAllowThreads();
26016 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
26017 wxPyEndAllowThreads(__tstate);
26018 if (PyErr_Occurred()) SWIG_fail;
26019 }
26020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
26021 return resultobj;
26022 fail:
26023 return NULL;
26024 }
26025
26026
26027 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26028 PyObject *resultobj = 0;
26029 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26030 wxSize result;
26031 void *argp1 = 0 ;
26032 int res1 = 0 ;
26033 PyObject *swig_obj[1] ;
26034
26035 if (!args) SWIG_fail;
26036 swig_obj[0] = args;
26037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26038 if (!SWIG_IsOK(res1)) {
26039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26040 }
26041 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26042 {
26043 PyThreadState* __tstate = wxPyBeginAllowThreads();
26044 result = ((wxSizeEvent const *)arg1)->GetSize();
26045 wxPyEndAllowThreads(__tstate);
26046 if (PyErr_Occurred()) SWIG_fail;
26047 }
26048 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
26049 return resultobj;
26050 fail:
26051 return NULL;
26052 }
26053
26054
26055 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26056 PyObject *resultobj = 0;
26057 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26058 wxRect result;
26059 void *argp1 = 0 ;
26060 int res1 = 0 ;
26061 PyObject *swig_obj[1] ;
26062
26063 if (!args) SWIG_fail;
26064 swig_obj[0] = args;
26065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26066 if (!SWIG_IsOK(res1)) {
26067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26068 }
26069 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26070 {
26071 PyThreadState* __tstate = wxPyBeginAllowThreads();
26072 result = ((wxSizeEvent const *)arg1)->GetRect();
26073 wxPyEndAllowThreads(__tstate);
26074 if (PyErr_Occurred()) SWIG_fail;
26075 }
26076 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26077 return resultobj;
26078 fail:
26079 return NULL;
26080 }
26081
26082
26083 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26084 PyObject *resultobj = 0;
26085 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26086 wxRect arg2 ;
26087 void *argp1 = 0 ;
26088 int res1 = 0 ;
26089 void *argp2 ;
26090 int res2 = 0 ;
26091 PyObject * obj0 = 0 ;
26092 PyObject * obj1 = 0 ;
26093 char * kwnames[] = {
26094 (char *) "self",(char *) "rect", NULL
26095 };
26096
26097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26099 if (!SWIG_IsOK(res1)) {
26100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26101 }
26102 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26103 {
26104 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26105 if (!SWIG_IsOK(res2)) {
26106 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26107 }
26108 if (!argp2) {
26109 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26110 } else {
26111 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26112 arg2 = *temp;
26113 if (SWIG_IsNewObj(res2)) delete temp;
26114 }
26115 }
26116 {
26117 PyThreadState* __tstate = wxPyBeginAllowThreads();
26118 (arg1)->SetRect(arg2);
26119 wxPyEndAllowThreads(__tstate);
26120 if (PyErr_Occurred()) SWIG_fail;
26121 }
26122 resultobj = SWIG_Py_Void();
26123 return resultobj;
26124 fail:
26125 return NULL;
26126 }
26127
26128
26129 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26130 PyObject *resultobj = 0;
26131 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26132 wxSize arg2 ;
26133 void *argp1 = 0 ;
26134 int res1 = 0 ;
26135 void *argp2 ;
26136 int res2 = 0 ;
26137 PyObject * obj0 = 0 ;
26138 PyObject * obj1 = 0 ;
26139 char * kwnames[] = {
26140 (char *) "self",(char *) "size", NULL
26141 };
26142
26143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26145 if (!SWIG_IsOK(res1)) {
26146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26147 }
26148 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26149 {
26150 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26151 if (!SWIG_IsOK(res2)) {
26152 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26153 }
26154 if (!argp2) {
26155 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26156 } else {
26157 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26158 arg2 = *temp;
26159 if (SWIG_IsNewObj(res2)) delete temp;
26160 }
26161 }
26162 {
26163 PyThreadState* __tstate = wxPyBeginAllowThreads();
26164 wxSizeEvent_SetSize(arg1,arg2);
26165 wxPyEndAllowThreads(__tstate);
26166 if (PyErr_Occurred()) SWIG_fail;
26167 }
26168 resultobj = SWIG_Py_Void();
26169 return resultobj;
26170 fail:
26171 return NULL;
26172 }
26173
26174
26175 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26176 PyObject *resultobj = 0;
26177 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26178 wxSize *arg2 = (wxSize *) 0 ;
26179 void *argp1 = 0 ;
26180 int res1 = 0 ;
26181 void *argp2 = 0 ;
26182 int res2 = 0 ;
26183 PyObject *swig_obj[2] ;
26184
26185 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26187 if (!SWIG_IsOK(res1)) {
26188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26189 }
26190 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26191 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26192 if (!SWIG_IsOK(res2)) {
26193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26194 }
26195 arg2 = reinterpret_cast< wxSize * >(argp2);
26196 if (arg1) (arg1)->m_size = *arg2;
26197
26198 resultobj = SWIG_Py_Void();
26199 return resultobj;
26200 fail:
26201 return NULL;
26202 }
26203
26204
26205 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26206 PyObject *resultobj = 0;
26207 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26208 wxSize *result = 0 ;
26209 void *argp1 = 0 ;
26210 int res1 = 0 ;
26211 PyObject *swig_obj[1] ;
26212
26213 if (!args) SWIG_fail;
26214 swig_obj[0] = args;
26215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26216 if (!SWIG_IsOK(res1)) {
26217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26218 }
26219 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26220 result = (wxSize *)& ((arg1)->m_size);
26221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26222 return resultobj;
26223 fail:
26224 return NULL;
26225 }
26226
26227
26228 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26229 PyObject *resultobj = 0;
26230 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26231 wxRect *arg2 = (wxRect *) 0 ;
26232 void *argp1 = 0 ;
26233 int res1 = 0 ;
26234 void *argp2 = 0 ;
26235 int res2 = 0 ;
26236 PyObject *swig_obj[2] ;
26237
26238 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26240 if (!SWIG_IsOK(res1)) {
26241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26242 }
26243 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26244 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26245 if (!SWIG_IsOK(res2)) {
26246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26247 }
26248 arg2 = reinterpret_cast< wxRect * >(argp2);
26249 if (arg1) (arg1)->m_rect = *arg2;
26250
26251 resultobj = SWIG_Py_Void();
26252 return resultobj;
26253 fail:
26254 return NULL;
26255 }
26256
26257
26258 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26259 PyObject *resultobj = 0;
26260 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26261 wxRect *result = 0 ;
26262 void *argp1 = 0 ;
26263 int res1 = 0 ;
26264 PyObject *swig_obj[1] ;
26265
26266 if (!args) SWIG_fail;
26267 swig_obj[0] = args;
26268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26269 if (!SWIG_IsOK(res1)) {
26270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26271 }
26272 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26273 result = (wxRect *)& ((arg1)->m_rect);
26274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26275 return resultobj;
26276 fail:
26277 return NULL;
26278 }
26279
26280
26281 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26282 PyObject *obj;
26283 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26284 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26285 return SWIG_Py_Void();
26286 }
26287
26288 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26289 return SWIG_Python_InitShadowInstance(args);
26290 }
26291
26292 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26293 PyObject *resultobj = 0;
26294 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26295 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26296 int arg2 = (int) 0 ;
26297 wxMoveEvent *result = 0 ;
26298 wxPoint temp1 ;
26299 int val2 ;
26300 int ecode2 = 0 ;
26301 PyObject * obj0 = 0 ;
26302 PyObject * obj1 = 0 ;
26303 char * kwnames[] = {
26304 (char *) "pos",(char *) "winid", NULL
26305 };
26306
26307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26308 if (obj0) {
26309 {
26310 arg1 = &temp1;
26311 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26312 }
26313 }
26314 if (obj1) {
26315 ecode2 = SWIG_AsVal_int(obj1, &val2);
26316 if (!SWIG_IsOK(ecode2)) {
26317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26318 }
26319 arg2 = static_cast< int >(val2);
26320 }
26321 {
26322 PyThreadState* __tstate = wxPyBeginAllowThreads();
26323 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26324 wxPyEndAllowThreads(__tstate);
26325 if (PyErr_Occurred()) SWIG_fail;
26326 }
26327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26328 return resultobj;
26329 fail:
26330 return NULL;
26331 }
26332
26333
26334 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26335 PyObject *resultobj = 0;
26336 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26337 wxPoint result;
26338 void *argp1 = 0 ;
26339 int res1 = 0 ;
26340 PyObject *swig_obj[1] ;
26341
26342 if (!args) SWIG_fail;
26343 swig_obj[0] = args;
26344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26345 if (!SWIG_IsOK(res1)) {
26346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26347 }
26348 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26349 {
26350 PyThreadState* __tstate = wxPyBeginAllowThreads();
26351 result = ((wxMoveEvent const *)arg1)->GetPosition();
26352 wxPyEndAllowThreads(__tstate);
26353 if (PyErr_Occurred()) SWIG_fail;
26354 }
26355 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26356 return resultobj;
26357 fail:
26358 return NULL;
26359 }
26360
26361
26362 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26363 PyObject *resultobj = 0;
26364 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26365 wxRect result;
26366 void *argp1 = 0 ;
26367 int res1 = 0 ;
26368 PyObject *swig_obj[1] ;
26369
26370 if (!args) SWIG_fail;
26371 swig_obj[0] = args;
26372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26373 if (!SWIG_IsOK(res1)) {
26374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26375 }
26376 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26377 {
26378 PyThreadState* __tstate = wxPyBeginAllowThreads();
26379 result = ((wxMoveEvent const *)arg1)->GetRect();
26380 wxPyEndAllowThreads(__tstate);
26381 if (PyErr_Occurred()) SWIG_fail;
26382 }
26383 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26384 return resultobj;
26385 fail:
26386 return NULL;
26387 }
26388
26389
26390 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26391 PyObject *resultobj = 0;
26392 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26393 wxRect *arg2 = 0 ;
26394 void *argp1 = 0 ;
26395 int res1 = 0 ;
26396 wxRect temp2 ;
26397 PyObject * obj0 = 0 ;
26398 PyObject * obj1 = 0 ;
26399 char * kwnames[] = {
26400 (char *) "self",(char *) "rect", NULL
26401 };
26402
26403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26405 if (!SWIG_IsOK(res1)) {
26406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26407 }
26408 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26409 {
26410 arg2 = &temp2;
26411 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26412 }
26413 {
26414 PyThreadState* __tstate = wxPyBeginAllowThreads();
26415 (arg1)->SetRect((wxRect const &)*arg2);
26416 wxPyEndAllowThreads(__tstate);
26417 if (PyErr_Occurred()) SWIG_fail;
26418 }
26419 resultobj = SWIG_Py_Void();
26420 return resultobj;
26421 fail:
26422 return NULL;
26423 }
26424
26425
26426 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26427 PyObject *resultobj = 0;
26428 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26429 wxPoint *arg2 = 0 ;
26430 void *argp1 = 0 ;
26431 int res1 = 0 ;
26432 wxPoint temp2 ;
26433 PyObject * obj0 = 0 ;
26434 PyObject * obj1 = 0 ;
26435 char * kwnames[] = {
26436 (char *) "self",(char *) "pos", NULL
26437 };
26438
26439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26441 if (!SWIG_IsOK(res1)) {
26442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26443 }
26444 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26445 {
26446 arg2 = &temp2;
26447 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26448 }
26449 {
26450 PyThreadState* __tstate = wxPyBeginAllowThreads();
26451 (arg1)->SetPosition((wxPoint const &)*arg2);
26452 wxPyEndAllowThreads(__tstate);
26453 if (PyErr_Occurred()) SWIG_fail;
26454 }
26455 resultobj = SWIG_Py_Void();
26456 return resultobj;
26457 fail:
26458 return NULL;
26459 }
26460
26461
26462 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26463 PyObject *obj;
26464 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26465 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26466 return SWIG_Py_Void();
26467 }
26468
26469 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26470 return SWIG_Python_InitShadowInstance(args);
26471 }
26472
26473 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26474 PyObject *resultobj = 0;
26475 int arg1 = (int) 0 ;
26476 wxPaintEvent *result = 0 ;
26477 int val1 ;
26478 int ecode1 = 0 ;
26479 PyObject * obj0 = 0 ;
26480 char * kwnames[] = {
26481 (char *) "Id", NULL
26482 };
26483
26484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26485 if (obj0) {
26486 ecode1 = SWIG_AsVal_int(obj0, &val1);
26487 if (!SWIG_IsOK(ecode1)) {
26488 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26489 }
26490 arg1 = static_cast< int >(val1);
26491 }
26492 {
26493 PyThreadState* __tstate = wxPyBeginAllowThreads();
26494 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26495 wxPyEndAllowThreads(__tstate);
26496 if (PyErr_Occurred()) SWIG_fail;
26497 }
26498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26499 return resultobj;
26500 fail:
26501 return NULL;
26502 }
26503
26504
26505 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26506 PyObject *obj;
26507 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26508 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26509 return SWIG_Py_Void();
26510 }
26511
26512 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26513 return SWIG_Python_InitShadowInstance(args);
26514 }
26515
26516 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26517 PyObject *resultobj = 0;
26518 int arg1 = (int) 0 ;
26519 wxNcPaintEvent *result = 0 ;
26520 int val1 ;
26521 int ecode1 = 0 ;
26522 PyObject * obj0 = 0 ;
26523 char * kwnames[] = {
26524 (char *) "winid", NULL
26525 };
26526
26527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26528 if (obj0) {
26529 ecode1 = SWIG_AsVal_int(obj0, &val1);
26530 if (!SWIG_IsOK(ecode1)) {
26531 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26532 }
26533 arg1 = static_cast< int >(val1);
26534 }
26535 {
26536 PyThreadState* __tstate = wxPyBeginAllowThreads();
26537 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26538 wxPyEndAllowThreads(__tstate);
26539 if (PyErr_Occurred()) SWIG_fail;
26540 }
26541 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26542 return resultobj;
26543 fail:
26544 return NULL;
26545 }
26546
26547
26548 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26549 PyObject *obj;
26550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26551 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26552 return SWIG_Py_Void();
26553 }
26554
26555 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26556 return SWIG_Python_InitShadowInstance(args);
26557 }
26558
26559 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26560 PyObject *resultobj = 0;
26561 int arg1 = (int) 0 ;
26562 wxDC *arg2 = (wxDC *) NULL ;
26563 wxEraseEvent *result = 0 ;
26564 int val1 ;
26565 int ecode1 = 0 ;
26566 void *argp2 = 0 ;
26567 int res2 = 0 ;
26568 PyObject * obj0 = 0 ;
26569 PyObject * obj1 = 0 ;
26570 char * kwnames[] = {
26571 (char *) "Id",(char *) "dc", NULL
26572 };
26573
26574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26575 if (obj0) {
26576 ecode1 = SWIG_AsVal_int(obj0, &val1);
26577 if (!SWIG_IsOK(ecode1)) {
26578 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26579 }
26580 arg1 = static_cast< int >(val1);
26581 }
26582 if (obj1) {
26583 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26584 if (!SWIG_IsOK(res2)) {
26585 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26586 }
26587 arg2 = reinterpret_cast< wxDC * >(argp2);
26588 }
26589 {
26590 PyThreadState* __tstate = wxPyBeginAllowThreads();
26591 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26592 wxPyEndAllowThreads(__tstate);
26593 if (PyErr_Occurred()) SWIG_fail;
26594 }
26595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26596 return resultobj;
26597 fail:
26598 return NULL;
26599 }
26600
26601
26602 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26603 PyObject *resultobj = 0;
26604 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26605 wxDC *result = 0 ;
26606 void *argp1 = 0 ;
26607 int res1 = 0 ;
26608 PyObject *swig_obj[1] ;
26609
26610 if (!args) SWIG_fail;
26611 swig_obj[0] = args;
26612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26613 if (!SWIG_IsOK(res1)) {
26614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26615 }
26616 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26617 {
26618 PyThreadState* __tstate = wxPyBeginAllowThreads();
26619 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26620 wxPyEndAllowThreads(__tstate);
26621 if (PyErr_Occurred()) SWIG_fail;
26622 }
26623 {
26624 resultobj = wxPyMake_wxObject(result, (bool)0);
26625 }
26626 return resultobj;
26627 fail:
26628 return NULL;
26629 }
26630
26631
26632 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26633 PyObject *obj;
26634 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26635 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26636 return SWIG_Py_Void();
26637 }
26638
26639 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26640 return SWIG_Python_InitShadowInstance(args);
26641 }
26642
26643 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26644 PyObject *resultobj = 0;
26645 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26646 int arg2 = (int) 0 ;
26647 wxFocusEvent *result = 0 ;
26648 int val1 ;
26649 int ecode1 = 0 ;
26650 int val2 ;
26651 int ecode2 = 0 ;
26652 PyObject * obj0 = 0 ;
26653 PyObject * obj1 = 0 ;
26654 char * kwnames[] = {
26655 (char *) "type",(char *) "winid", NULL
26656 };
26657
26658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26659 if (obj0) {
26660 ecode1 = SWIG_AsVal_int(obj0, &val1);
26661 if (!SWIG_IsOK(ecode1)) {
26662 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26663 }
26664 arg1 = static_cast< wxEventType >(val1);
26665 }
26666 if (obj1) {
26667 ecode2 = SWIG_AsVal_int(obj1, &val2);
26668 if (!SWIG_IsOK(ecode2)) {
26669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26670 }
26671 arg2 = static_cast< int >(val2);
26672 }
26673 {
26674 PyThreadState* __tstate = wxPyBeginAllowThreads();
26675 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26676 wxPyEndAllowThreads(__tstate);
26677 if (PyErr_Occurred()) SWIG_fail;
26678 }
26679 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26680 return resultobj;
26681 fail:
26682 return NULL;
26683 }
26684
26685
26686 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26687 PyObject *resultobj = 0;
26688 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26689 wxWindow *result = 0 ;
26690 void *argp1 = 0 ;
26691 int res1 = 0 ;
26692 PyObject *swig_obj[1] ;
26693
26694 if (!args) SWIG_fail;
26695 swig_obj[0] = args;
26696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26697 if (!SWIG_IsOK(res1)) {
26698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26699 }
26700 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26701 {
26702 PyThreadState* __tstate = wxPyBeginAllowThreads();
26703 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26704 wxPyEndAllowThreads(__tstate);
26705 if (PyErr_Occurred()) SWIG_fail;
26706 }
26707 {
26708 resultobj = wxPyMake_wxObject(result, (bool)0);
26709 }
26710 return resultobj;
26711 fail:
26712 return NULL;
26713 }
26714
26715
26716 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26717 PyObject *resultobj = 0;
26718 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26719 wxWindow *arg2 = (wxWindow *) 0 ;
26720 void *argp1 = 0 ;
26721 int res1 = 0 ;
26722 void *argp2 = 0 ;
26723 int res2 = 0 ;
26724 PyObject * obj0 = 0 ;
26725 PyObject * obj1 = 0 ;
26726 char * kwnames[] = {
26727 (char *) "self",(char *) "win", NULL
26728 };
26729
26730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26732 if (!SWIG_IsOK(res1)) {
26733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26734 }
26735 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26736 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26737 if (!SWIG_IsOK(res2)) {
26738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26739 }
26740 arg2 = reinterpret_cast< wxWindow * >(argp2);
26741 {
26742 PyThreadState* __tstate = wxPyBeginAllowThreads();
26743 (arg1)->SetWindow(arg2);
26744 wxPyEndAllowThreads(__tstate);
26745 if (PyErr_Occurred()) SWIG_fail;
26746 }
26747 resultobj = SWIG_Py_Void();
26748 return resultobj;
26749 fail:
26750 return NULL;
26751 }
26752
26753
26754 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26755 PyObject *obj;
26756 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26757 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26758 return SWIG_Py_Void();
26759 }
26760
26761 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26762 return SWIG_Python_InitShadowInstance(args);
26763 }
26764
26765 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26766 PyObject *resultobj = 0;
26767 wxWindow *arg1 = (wxWindow *) NULL ;
26768 wxChildFocusEvent *result = 0 ;
26769 void *argp1 = 0 ;
26770 int res1 = 0 ;
26771 PyObject * obj0 = 0 ;
26772 char * kwnames[] = {
26773 (char *) "win", NULL
26774 };
26775
26776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26777 if (obj0) {
26778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26779 if (!SWIG_IsOK(res1)) {
26780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26781 }
26782 arg1 = reinterpret_cast< wxWindow * >(argp1);
26783 }
26784 {
26785 PyThreadState* __tstate = wxPyBeginAllowThreads();
26786 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26787 wxPyEndAllowThreads(__tstate);
26788 if (PyErr_Occurred()) SWIG_fail;
26789 }
26790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26791 return resultobj;
26792 fail:
26793 return NULL;
26794 }
26795
26796
26797 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26798 PyObject *resultobj = 0;
26799 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26800 wxWindow *result = 0 ;
26801 void *argp1 = 0 ;
26802 int res1 = 0 ;
26803 PyObject *swig_obj[1] ;
26804
26805 if (!args) SWIG_fail;
26806 swig_obj[0] = args;
26807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26808 if (!SWIG_IsOK(res1)) {
26809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26810 }
26811 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26812 {
26813 PyThreadState* __tstate = wxPyBeginAllowThreads();
26814 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26815 wxPyEndAllowThreads(__tstate);
26816 if (PyErr_Occurred()) SWIG_fail;
26817 }
26818 {
26819 resultobj = wxPyMake_wxObject(result, (bool)0);
26820 }
26821 return resultobj;
26822 fail:
26823 return NULL;
26824 }
26825
26826
26827 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26828 PyObject *obj;
26829 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26830 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26831 return SWIG_Py_Void();
26832 }
26833
26834 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26835 return SWIG_Python_InitShadowInstance(args);
26836 }
26837
26838 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26839 PyObject *resultobj = 0;
26840 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26841 bool arg2 = (bool) true ;
26842 int arg3 = (int) 0 ;
26843 wxActivateEvent *result = 0 ;
26844 int val1 ;
26845 int ecode1 = 0 ;
26846 bool val2 ;
26847 int ecode2 = 0 ;
26848 int val3 ;
26849 int ecode3 = 0 ;
26850 PyObject * obj0 = 0 ;
26851 PyObject * obj1 = 0 ;
26852 PyObject * obj2 = 0 ;
26853 char * kwnames[] = {
26854 (char *) "type",(char *) "active",(char *) "Id", NULL
26855 };
26856
26857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26858 if (obj0) {
26859 ecode1 = SWIG_AsVal_int(obj0, &val1);
26860 if (!SWIG_IsOK(ecode1)) {
26861 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26862 }
26863 arg1 = static_cast< wxEventType >(val1);
26864 }
26865 if (obj1) {
26866 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26867 if (!SWIG_IsOK(ecode2)) {
26868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26869 }
26870 arg2 = static_cast< bool >(val2);
26871 }
26872 if (obj2) {
26873 ecode3 = SWIG_AsVal_int(obj2, &val3);
26874 if (!SWIG_IsOK(ecode3)) {
26875 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26876 }
26877 arg3 = static_cast< int >(val3);
26878 }
26879 {
26880 PyThreadState* __tstate = wxPyBeginAllowThreads();
26881 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26882 wxPyEndAllowThreads(__tstate);
26883 if (PyErr_Occurred()) SWIG_fail;
26884 }
26885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26886 return resultobj;
26887 fail:
26888 return NULL;
26889 }
26890
26891
26892 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26893 PyObject *resultobj = 0;
26894 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26895 bool result;
26896 void *argp1 = 0 ;
26897 int res1 = 0 ;
26898 PyObject *swig_obj[1] ;
26899
26900 if (!args) SWIG_fail;
26901 swig_obj[0] = args;
26902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26903 if (!SWIG_IsOK(res1)) {
26904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26905 }
26906 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26907 {
26908 PyThreadState* __tstate = wxPyBeginAllowThreads();
26909 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26910 wxPyEndAllowThreads(__tstate);
26911 if (PyErr_Occurred()) SWIG_fail;
26912 }
26913 {
26914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26915 }
26916 return resultobj;
26917 fail:
26918 return NULL;
26919 }
26920
26921
26922 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26923 PyObject *obj;
26924 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26925 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26926 return SWIG_Py_Void();
26927 }
26928
26929 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26930 return SWIG_Python_InitShadowInstance(args);
26931 }
26932
26933 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26934 PyObject *resultobj = 0;
26935 int arg1 = (int) 0 ;
26936 wxInitDialogEvent *result = 0 ;
26937 int val1 ;
26938 int ecode1 = 0 ;
26939 PyObject * obj0 = 0 ;
26940 char * kwnames[] = {
26941 (char *) "Id", NULL
26942 };
26943
26944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26945 if (obj0) {
26946 ecode1 = SWIG_AsVal_int(obj0, &val1);
26947 if (!SWIG_IsOK(ecode1)) {
26948 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26949 }
26950 arg1 = static_cast< int >(val1);
26951 }
26952 {
26953 PyThreadState* __tstate = wxPyBeginAllowThreads();
26954 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26955 wxPyEndAllowThreads(__tstate);
26956 if (PyErr_Occurred()) SWIG_fail;
26957 }
26958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26959 return resultobj;
26960 fail:
26961 return NULL;
26962 }
26963
26964
26965 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26966 PyObject *obj;
26967 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26968 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26969 return SWIG_Py_Void();
26970 }
26971
26972 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26973 return SWIG_Python_InitShadowInstance(args);
26974 }
26975
26976 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26977 PyObject *resultobj = 0;
26978 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26979 int arg2 = (int) 0 ;
26980 wxMenu *arg3 = (wxMenu *) NULL ;
26981 wxMenuEvent *result = 0 ;
26982 int val1 ;
26983 int ecode1 = 0 ;
26984 int val2 ;
26985 int ecode2 = 0 ;
26986 void *argp3 = 0 ;
26987 int res3 = 0 ;
26988 PyObject * obj0 = 0 ;
26989 PyObject * obj1 = 0 ;
26990 PyObject * obj2 = 0 ;
26991 char * kwnames[] = {
26992 (char *) "type",(char *) "winid",(char *) "menu", NULL
26993 };
26994
26995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26996 if (obj0) {
26997 ecode1 = SWIG_AsVal_int(obj0, &val1);
26998 if (!SWIG_IsOK(ecode1)) {
26999 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27000 }
27001 arg1 = static_cast< wxEventType >(val1);
27002 }
27003 if (obj1) {
27004 ecode2 = SWIG_AsVal_int(obj1, &val2);
27005 if (!SWIG_IsOK(ecode2)) {
27006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
27007 }
27008 arg2 = static_cast< int >(val2);
27009 }
27010 if (obj2) {
27011 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
27012 if (!SWIG_IsOK(res3)) {
27013 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
27014 }
27015 arg3 = reinterpret_cast< wxMenu * >(argp3);
27016 }
27017 {
27018 PyThreadState* __tstate = wxPyBeginAllowThreads();
27019 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
27020 wxPyEndAllowThreads(__tstate);
27021 if (PyErr_Occurred()) SWIG_fail;
27022 }
27023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
27024 return resultobj;
27025 fail:
27026 return NULL;
27027 }
27028
27029
27030 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27031 PyObject *resultobj = 0;
27032 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27033 int result;
27034 void *argp1 = 0 ;
27035 int res1 = 0 ;
27036 PyObject *swig_obj[1] ;
27037
27038 if (!args) SWIG_fail;
27039 swig_obj[0] = args;
27040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27041 if (!SWIG_IsOK(res1)) {
27042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27043 }
27044 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27045 {
27046 PyThreadState* __tstate = wxPyBeginAllowThreads();
27047 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
27048 wxPyEndAllowThreads(__tstate);
27049 if (PyErr_Occurred()) SWIG_fail;
27050 }
27051 resultobj = SWIG_From_int(static_cast< int >(result));
27052 return resultobj;
27053 fail:
27054 return NULL;
27055 }
27056
27057
27058 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27059 PyObject *resultobj = 0;
27060 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27061 bool result;
27062 void *argp1 = 0 ;
27063 int res1 = 0 ;
27064 PyObject *swig_obj[1] ;
27065
27066 if (!args) SWIG_fail;
27067 swig_obj[0] = args;
27068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27069 if (!SWIG_IsOK(res1)) {
27070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27071 }
27072 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27073 {
27074 PyThreadState* __tstate = wxPyBeginAllowThreads();
27075 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
27076 wxPyEndAllowThreads(__tstate);
27077 if (PyErr_Occurred()) SWIG_fail;
27078 }
27079 {
27080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27081 }
27082 return resultobj;
27083 fail:
27084 return NULL;
27085 }
27086
27087
27088 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27089 PyObject *resultobj = 0;
27090 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27091 wxMenu *result = 0 ;
27092 void *argp1 = 0 ;
27093 int res1 = 0 ;
27094 PyObject *swig_obj[1] ;
27095
27096 if (!args) SWIG_fail;
27097 swig_obj[0] = args;
27098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27099 if (!SWIG_IsOK(res1)) {
27100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27101 }
27102 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27103 {
27104 PyThreadState* __tstate = wxPyBeginAllowThreads();
27105 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27106 wxPyEndAllowThreads(__tstate);
27107 if (PyErr_Occurred()) SWIG_fail;
27108 }
27109 {
27110 resultobj = wxPyMake_wxObject(result, (bool)0);
27111 }
27112 return resultobj;
27113 fail:
27114 return NULL;
27115 }
27116
27117
27118 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27119 PyObject *obj;
27120 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27121 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27122 return SWIG_Py_Void();
27123 }
27124
27125 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27126 return SWIG_Python_InitShadowInstance(args);
27127 }
27128
27129 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27130 PyObject *resultobj = 0;
27131 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27132 int arg2 = (int) 0 ;
27133 wxCloseEvent *result = 0 ;
27134 int val1 ;
27135 int ecode1 = 0 ;
27136 int val2 ;
27137 int ecode2 = 0 ;
27138 PyObject * obj0 = 0 ;
27139 PyObject * obj1 = 0 ;
27140 char * kwnames[] = {
27141 (char *) "type",(char *) "winid", NULL
27142 };
27143
27144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27145 if (obj0) {
27146 ecode1 = SWIG_AsVal_int(obj0, &val1);
27147 if (!SWIG_IsOK(ecode1)) {
27148 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27149 }
27150 arg1 = static_cast< wxEventType >(val1);
27151 }
27152 if (obj1) {
27153 ecode2 = SWIG_AsVal_int(obj1, &val2);
27154 if (!SWIG_IsOK(ecode2)) {
27155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27156 }
27157 arg2 = static_cast< int >(val2);
27158 }
27159 {
27160 PyThreadState* __tstate = wxPyBeginAllowThreads();
27161 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27162 wxPyEndAllowThreads(__tstate);
27163 if (PyErr_Occurred()) SWIG_fail;
27164 }
27165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27166 return resultobj;
27167 fail:
27168 return NULL;
27169 }
27170
27171
27172 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27173 PyObject *resultobj = 0;
27174 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27175 bool arg2 ;
27176 void *argp1 = 0 ;
27177 int res1 = 0 ;
27178 bool val2 ;
27179 int ecode2 = 0 ;
27180 PyObject * obj0 = 0 ;
27181 PyObject * obj1 = 0 ;
27182 char * kwnames[] = {
27183 (char *) "self",(char *) "logOff", NULL
27184 };
27185
27186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27188 if (!SWIG_IsOK(res1)) {
27189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27190 }
27191 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27192 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27193 if (!SWIG_IsOK(ecode2)) {
27194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27195 }
27196 arg2 = static_cast< bool >(val2);
27197 {
27198 PyThreadState* __tstate = wxPyBeginAllowThreads();
27199 (arg1)->SetLoggingOff(arg2);
27200 wxPyEndAllowThreads(__tstate);
27201 if (PyErr_Occurred()) SWIG_fail;
27202 }
27203 resultobj = SWIG_Py_Void();
27204 return resultobj;
27205 fail:
27206 return NULL;
27207 }
27208
27209
27210 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27211 PyObject *resultobj = 0;
27212 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27213 bool result;
27214 void *argp1 = 0 ;
27215 int res1 = 0 ;
27216 PyObject *swig_obj[1] ;
27217
27218 if (!args) SWIG_fail;
27219 swig_obj[0] = args;
27220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27221 if (!SWIG_IsOK(res1)) {
27222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27223 }
27224 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27225 {
27226 PyThreadState* __tstate = wxPyBeginAllowThreads();
27227 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27228 wxPyEndAllowThreads(__tstate);
27229 if (PyErr_Occurred()) SWIG_fail;
27230 }
27231 {
27232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27233 }
27234 return resultobj;
27235 fail:
27236 return NULL;
27237 }
27238
27239
27240 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27241 PyObject *resultobj = 0;
27242 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27243 bool arg2 = (bool) true ;
27244 void *argp1 = 0 ;
27245 int res1 = 0 ;
27246 bool val2 ;
27247 int ecode2 = 0 ;
27248 PyObject * obj0 = 0 ;
27249 PyObject * obj1 = 0 ;
27250 char * kwnames[] = {
27251 (char *) "self",(char *) "veto", NULL
27252 };
27253
27254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27256 if (!SWIG_IsOK(res1)) {
27257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27258 }
27259 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27260 if (obj1) {
27261 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27262 if (!SWIG_IsOK(ecode2)) {
27263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27264 }
27265 arg2 = static_cast< bool >(val2);
27266 }
27267 {
27268 PyThreadState* __tstate = wxPyBeginAllowThreads();
27269 (arg1)->Veto(arg2);
27270 wxPyEndAllowThreads(__tstate);
27271 if (PyErr_Occurred()) SWIG_fail;
27272 }
27273 resultobj = SWIG_Py_Void();
27274 return resultobj;
27275 fail:
27276 return NULL;
27277 }
27278
27279
27280 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27281 PyObject *resultobj = 0;
27282 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27283 bool result;
27284 void *argp1 = 0 ;
27285 int res1 = 0 ;
27286 PyObject *swig_obj[1] ;
27287
27288 if (!args) SWIG_fail;
27289 swig_obj[0] = args;
27290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27291 if (!SWIG_IsOK(res1)) {
27292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27293 }
27294 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27295 {
27296 PyThreadState* __tstate = wxPyBeginAllowThreads();
27297 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27298 wxPyEndAllowThreads(__tstate);
27299 if (PyErr_Occurred()) SWIG_fail;
27300 }
27301 {
27302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27303 }
27304 return resultobj;
27305 fail:
27306 return NULL;
27307 }
27308
27309
27310 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27311 PyObject *resultobj = 0;
27312 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27313 bool arg2 ;
27314 void *argp1 = 0 ;
27315 int res1 = 0 ;
27316 bool val2 ;
27317 int ecode2 = 0 ;
27318 PyObject * obj0 = 0 ;
27319 PyObject * obj1 = 0 ;
27320 char * kwnames[] = {
27321 (char *) "self",(char *) "canVeto", NULL
27322 };
27323
27324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27326 if (!SWIG_IsOK(res1)) {
27327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27328 }
27329 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27330 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27331 if (!SWIG_IsOK(ecode2)) {
27332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27333 }
27334 arg2 = static_cast< bool >(val2);
27335 {
27336 PyThreadState* __tstate = wxPyBeginAllowThreads();
27337 (arg1)->SetCanVeto(arg2);
27338 wxPyEndAllowThreads(__tstate);
27339 if (PyErr_Occurred()) SWIG_fail;
27340 }
27341 resultobj = SWIG_Py_Void();
27342 return resultobj;
27343 fail:
27344 return NULL;
27345 }
27346
27347
27348 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27349 PyObject *resultobj = 0;
27350 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27351 bool result;
27352 void *argp1 = 0 ;
27353 int res1 = 0 ;
27354 PyObject *swig_obj[1] ;
27355
27356 if (!args) SWIG_fail;
27357 swig_obj[0] = args;
27358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27359 if (!SWIG_IsOK(res1)) {
27360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27361 }
27362 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27363 {
27364 PyThreadState* __tstate = wxPyBeginAllowThreads();
27365 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27366 wxPyEndAllowThreads(__tstate);
27367 if (PyErr_Occurred()) SWIG_fail;
27368 }
27369 {
27370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27371 }
27372 return resultobj;
27373 fail:
27374 return NULL;
27375 }
27376
27377
27378 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27379 PyObject *obj;
27380 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27381 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27382 return SWIG_Py_Void();
27383 }
27384
27385 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27386 return SWIG_Python_InitShadowInstance(args);
27387 }
27388
27389 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27390 PyObject *resultobj = 0;
27391 int arg1 = (int) 0 ;
27392 bool arg2 = (bool) false ;
27393 wxShowEvent *result = 0 ;
27394 int val1 ;
27395 int ecode1 = 0 ;
27396 bool val2 ;
27397 int ecode2 = 0 ;
27398 PyObject * obj0 = 0 ;
27399 PyObject * obj1 = 0 ;
27400 char * kwnames[] = {
27401 (char *) "winid",(char *) "show", NULL
27402 };
27403
27404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27405 if (obj0) {
27406 ecode1 = SWIG_AsVal_int(obj0, &val1);
27407 if (!SWIG_IsOK(ecode1)) {
27408 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27409 }
27410 arg1 = static_cast< int >(val1);
27411 }
27412 if (obj1) {
27413 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27414 if (!SWIG_IsOK(ecode2)) {
27415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27416 }
27417 arg2 = static_cast< bool >(val2);
27418 }
27419 {
27420 PyThreadState* __tstate = wxPyBeginAllowThreads();
27421 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27422 wxPyEndAllowThreads(__tstate);
27423 if (PyErr_Occurred()) SWIG_fail;
27424 }
27425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27426 return resultobj;
27427 fail:
27428 return NULL;
27429 }
27430
27431
27432 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27433 PyObject *resultobj = 0;
27434 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27435 bool arg2 ;
27436 void *argp1 = 0 ;
27437 int res1 = 0 ;
27438 bool val2 ;
27439 int ecode2 = 0 ;
27440 PyObject * obj0 = 0 ;
27441 PyObject * obj1 = 0 ;
27442 char * kwnames[] = {
27443 (char *) "self",(char *) "show", NULL
27444 };
27445
27446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27448 if (!SWIG_IsOK(res1)) {
27449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27450 }
27451 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27452 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27453 if (!SWIG_IsOK(ecode2)) {
27454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27455 }
27456 arg2 = static_cast< bool >(val2);
27457 {
27458 PyThreadState* __tstate = wxPyBeginAllowThreads();
27459 (arg1)->SetShow(arg2);
27460 wxPyEndAllowThreads(__tstate);
27461 if (PyErr_Occurred()) SWIG_fail;
27462 }
27463 resultobj = SWIG_Py_Void();
27464 return resultobj;
27465 fail:
27466 return NULL;
27467 }
27468
27469
27470 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27471 PyObject *resultobj = 0;
27472 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27473 bool result;
27474 void *argp1 = 0 ;
27475 int res1 = 0 ;
27476 PyObject *swig_obj[1] ;
27477
27478 if (!args) SWIG_fail;
27479 swig_obj[0] = args;
27480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27481 if (!SWIG_IsOK(res1)) {
27482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27483 }
27484 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27485 {
27486 PyThreadState* __tstate = wxPyBeginAllowThreads();
27487 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27488 wxPyEndAllowThreads(__tstate);
27489 if (PyErr_Occurred()) SWIG_fail;
27490 }
27491 {
27492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27493 }
27494 return resultobj;
27495 fail:
27496 return NULL;
27497 }
27498
27499
27500 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27501 PyObject *obj;
27502 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27503 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27504 return SWIG_Py_Void();
27505 }
27506
27507 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27508 return SWIG_Python_InitShadowInstance(args);
27509 }
27510
27511 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27512 PyObject *resultobj = 0;
27513 int arg1 = (int) 0 ;
27514 bool arg2 = (bool) true ;
27515 wxIconizeEvent *result = 0 ;
27516 int val1 ;
27517 int ecode1 = 0 ;
27518 bool val2 ;
27519 int ecode2 = 0 ;
27520 PyObject * obj0 = 0 ;
27521 PyObject * obj1 = 0 ;
27522 char * kwnames[] = {
27523 (char *) "id",(char *) "iconized", NULL
27524 };
27525
27526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27527 if (obj0) {
27528 ecode1 = SWIG_AsVal_int(obj0, &val1);
27529 if (!SWIG_IsOK(ecode1)) {
27530 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27531 }
27532 arg1 = static_cast< int >(val1);
27533 }
27534 if (obj1) {
27535 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27536 if (!SWIG_IsOK(ecode2)) {
27537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27538 }
27539 arg2 = static_cast< bool >(val2);
27540 }
27541 {
27542 PyThreadState* __tstate = wxPyBeginAllowThreads();
27543 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27544 wxPyEndAllowThreads(__tstate);
27545 if (PyErr_Occurred()) SWIG_fail;
27546 }
27547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27548 return resultobj;
27549 fail:
27550 return NULL;
27551 }
27552
27553
27554 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27555 PyObject *resultobj = 0;
27556 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27557 bool result;
27558 void *argp1 = 0 ;
27559 int res1 = 0 ;
27560 PyObject *swig_obj[1] ;
27561
27562 if (!args) SWIG_fail;
27563 swig_obj[0] = args;
27564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27565 if (!SWIG_IsOK(res1)) {
27566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27567 }
27568 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27569 {
27570 PyThreadState* __tstate = wxPyBeginAllowThreads();
27571 result = (bool)(arg1)->Iconized();
27572 wxPyEndAllowThreads(__tstate);
27573 if (PyErr_Occurred()) SWIG_fail;
27574 }
27575 {
27576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27577 }
27578 return resultobj;
27579 fail:
27580 return NULL;
27581 }
27582
27583
27584 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27585 PyObject *obj;
27586 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27587 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27588 return SWIG_Py_Void();
27589 }
27590
27591 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27592 return SWIG_Python_InitShadowInstance(args);
27593 }
27594
27595 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27596 PyObject *resultobj = 0;
27597 int arg1 = (int) 0 ;
27598 wxMaximizeEvent *result = 0 ;
27599 int val1 ;
27600 int ecode1 = 0 ;
27601 PyObject * obj0 = 0 ;
27602 char * kwnames[] = {
27603 (char *) "id", NULL
27604 };
27605
27606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27607 if (obj0) {
27608 ecode1 = SWIG_AsVal_int(obj0, &val1);
27609 if (!SWIG_IsOK(ecode1)) {
27610 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27611 }
27612 arg1 = static_cast< int >(val1);
27613 }
27614 {
27615 PyThreadState* __tstate = wxPyBeginAllowThreads();
27616 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27617 wxPyEndAllowThreads(__tstate);
27618 if (PyErr_Occurred()) SWIG_fail;
27619 }
27620 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27621 return resultobj;
27622 fail:
27623 return NULL;
27624 }
27625
27626
27627 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27628 PyObject *obj;
27629 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27630 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27631 return SWIG_Py_Void();
27632 }
27633
27634 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27635 return SWIG_Python_InitShadowInstance(args);
27636 }
27637
27638 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27639 PyObject *resultobj = 0;
27640 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27641 wxPoint result;
27642 void *argp1 = 0 ;
27643 int res1 = 0 ;
27644 PyObject *swig_obj[1] ;
27645
27646 if (!args) SWIG_fail;
27647 swig_obj[0] = args;
27648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27649 if (!SWIG_IsOK(res1)) {
27650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27651 }
27652 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27653 {
27654 PyThreadState* __tstate = wxPyBeginAllowThreads();
27655 result = (arg1)->GetPosition();
27656 wxPyEndAllowThreads(__tstate);
27657 if (PyErr_Occurred()) SWIG_fail;
27658 }
27659 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27660 return resultobj;
27661 fail:
27662 return NULL;
27663 }
27664
27665
27666 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27667 PyObject *resultobj = 0;
27668 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27669 int result;
27670 void *argp1 = 0 ;
27671 int res1 = 0 ;
27672 PyObject *swig_obj[1] ;
27673
27674 if (!args) SWIG_fail;
27675 swig_obj[0] = args;
27676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27677 if (!SWIG_IsOK(res1)) {
27678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27679 }
27680 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27681 {
27682 PyThreadState* __tstate = wxPyBeginAllowThreads();
27683 result = (int)(arg1)->GetNumberOfFiles();
27684 wxPyEndAllowThreads(__tstate);
27685 if (PyErr_Occurred()) SWIG_fail;
27686 }
27687 resultobj = SWIG_From_int(static_cast< int >(result));
27688 return resultobj;
27689 fail:
27690 return NULL;
27691 }
27692
27693
27694 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27695 PyObject *resultobj = 0;
27696 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27697 PyObject *result = 0 ;
27698 void *argp1 = 0 ;
27699 int res1 = 0 ;
27700 PyObject *swig_obj[1] ;
27701
27702 if (!args) SWIG_fail;
27703 swig_obj[0] = args;
27704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27705 if (!SWIG_IsOK(res1)) {
27706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27707 }
27708 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27709 {
27710 PyThreadState* __tstate = wxPyBeginAllowThreads();
27711 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27712 wxPyEndAllowThreads(__tstate);
27713 if (PyErr_Occurred()) SWIG_fail;
27714 }
27715 resultobj = result;
27716 return resultobj;
27717 fail:
27718 return NULL;
27719 }
27720
27721
27722 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27723 PyObject *obj;
27724 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27725 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27726 return SWIG_Py_Void();
27727 }
27728
27729 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27730 PyObject *resultobj = 0;
27731 int arg1 = (int) 0 ;
27732 wxUpdateUIEvent *result = 0 ;
27733 int val1 ;
27734 int ecode1 = 0 ;
27735 PyObject * obj0 = 0 ;
27736 char * kwnames[] = {
27737 (char *) "commandId", NULL
27738 };
27739
27740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27741 if (obj0) {
27742 ecode1 = SWIG_AsVal_int(obj0, &val1);
27743 if (!SWIG_IsOK(ecode1)) {
27744 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27745 }
27746 arg1 = static_cast< int >(val1);
27747 }
27748 {
27749 PyThreadState* __tstate = wxPyBeginAllowThreads();
27750 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27751 wxPyEndAllowThreads(__tstate);
27752 if (PyErr_Occurred()) SWIG_fail;
27753 }
27754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27755 return resultobj;
27756 fail:
27757 return NULL;
27758 }
27759
27760
27761 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27762 PyObject *resultobj = 0;
27763 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27764 bool result;
27765 void *argp1 = 0 ;
27766 int res1 = 0 ;
27767 PyObject *swig_obj[1] ;
27768
27769 if (!args) SWIG_fail;
27770 swig_obj[0] = args;
27771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27772 if (!SWIG_IsOK(res1)) {
27773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27774 }
27775 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27776 {
27777 PyThreadState* __tstate = wxPyBeginAllowThreads();
27778 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27779 wxPyEndAllowThreads(__tstate);
27780 if (PyErr_Occurred()) SWIG_fail;
27781 }
27782 {
27783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27784 }
27785 return resultobj;
27786 fail:
27787 return NULL;
27788 }
27789
27790
27791 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27792 PyObject *resultobj = 0;
27793 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27794 bool result;
27795 void *argp1 = 0 ;
27796 int res1 = 0 ;
27797 PyObject *swig_obj[1] ;
27798
27799 if (!args) SWIG_fail;
27800 swig_obj[0] = args;
27801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27802 if (!SWIG_IsOK(res1)) {
27803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27804 }
27805 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27806 {
27807 PyThreadState* __tstate = wxPyBeginAllowThreads();
27808 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27809 wxPyEndAllowThreads(__tstate);
27810 if (PyErr_Occurred()) SWIG_fail;
27811 }
27812 {
27813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27814 }
27815 return resultobj;
27816 fail:
27817 return NULL;
27818 }
27819
27820
27821 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27822 PyObject *resultobj = 0;
27823 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27824 bool result;
27825 void *argp1 = 0 ;
27826 int res1 = 0 ;
27827 PyObject *swig_obj[1] ;
27828
27829 if (!args) SWIG_fail;
27830 swig_obj[0] = args;
27831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27832 if (!SWIG_IsOK(res1)) {
27833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27834 }
27835 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27836 {
27837 PyThreadState* __tstate = wxPyBeginAllowThreads();
27838 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27839 wxPyEndAllowThreads(__tstate);
27840 if (PyErr_Occurred()) SWIG_fail;
27841 }
27842 {
27843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27844 }
27845 return resultobj;
27846 fail:
27847 return NULL;
27848 }
27849
27850
27851 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27852 PyObject *resultobj = 0;
27853 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27854 wxString result;
27855 void *argp1 = 0 ;
27856 int res1 = 0 ;
27857 PyObject *swig_obj[1] ;
27858
27859 if (!args) SWIG_fail;
27860 swig_obj[0] = args;
27861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27862 if (!SWIG_IsOK(res1)) {
27863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27864 }
27865 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27866 {
27867 PyThreadState* __tstate = wxPyBeginAllowThreads();
27868 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27869 wxPyEndAllowThreads(__tstate);
27870 if (PyErr_Occurred()) SWIG_fail;
27871 }
27872 {
27873 #if wxUSE_UNICODE
27874 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27875 #else
27876 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27877 #endif
27878 }
27879 return resultobj;
27880 fail:
27881 return NULL;
27882 }
27883
27884
27885 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27886 PyObject *resultobj = 0;
27887 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27888 bool result;
27889 void *argp1 = 0 ;
27890 int res1 = 0 ;
27891 PyObject *swig_obj[1] ;
27892
27893 if (!args) SWIG_fail;
27894 swig_obj[0] = args;
27895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27896 if (!SWIG_IsOK(res1)) {
27897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27898 }
27899 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27900 {
27901 PyThreadState* __tstate = wxPyBeginAllowThreads();
27902 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27903 wxPyEndAllowThreads(__tstate);
27904 if (PyErr_Occurred()) SWIG_fail;
27905 }
27906 {
27907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27908 }
27909 return resultobj;
27910 fail:
27911 return NULL;
27912 }
27913
27914
27915 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27916 PyObject *resultobj = 0;
27917 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27918 bool result;
27919 void *argp1 = 0 ;
27920 int res1 = 0 ;
27921 PyObject *swig_obj[1] ;
27922
27923 if (!args) SWIG_fail;
27924 swig_obj[0] = args;
27925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27926 if (!SWIG_IsOK(res1)) {
27927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27928 }
27929 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27930 {
27931 PyThreadState* __tstate = wxPyBeginAllowThreads();
27932 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27933 wxPyEndAllowThreads(__tstate);
27934 if (PyErr_Occurred()) SWIG_fail;
27935 }
27936 {
27937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27938 }
27939 return resultobj;
27940 fail:
27941 return NULL;
27942 }
27943
27944
27945 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27946 PyObject *resultobj = 0;
27947 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27948 bool result;
27949 void *argp1 = 0 ;
27950 int res1 = 0 ;
27951 PyObject *swig_obj[1] ;
27952
27953 if (!args) SWIG_fail;
27954 swig_obj[0] = args;
27955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27956 if (!SWIG_IsOK(res1)) {
27957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27958 }
27959 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27960 {
27961 PyThreadState* __tstate = wxPyBeginAllowThreads();
27962 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27963 wxPyEndAllowThreads(__tstate);
27964 if (PyErr_Occurred()) SWIG_fail;
27965 }
27966 {
27967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27968 }
27969 return resultobj;
27970 fail:
27971 return NULL;
27972 }
27973
27974
27975 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27976 PyObject *resultobj = 0;
27977 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27978 bool result;
27979 void *argp1 = 0 ;
27980 int res1 = 0 ;
27981 PyObject *swig_obj[1] ;
27982
27983 if (!args) SWIG_fail;
27984 swig_obj[0] = args;
27985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27986 if (!SWIG_IsOK(res1)) {
27987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27988 }
27989 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27990 {
27991 PyThreadState* __tstate = wxPyBeginAllowThreads();
27992 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
27993 wxPyEndAllowThreads(__tstate);
27994 if (PyErr_Occurred()) SWIG_fail;
27995 }
27996 {
27997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27998 }
27999 return resultobj;
28000 fail:
28001 return NULL;
28002 }
28003
28004
28005 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28006 PyObject *resultobj = 0;
28007 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28008 bool arg2 ;
28009 void *argp1 = 0 ;
28010 int res1 = 0 ;
28011 bool val2 ;
28012 int ecode2 = 0 ;
28013 PyObject * obj0 = 0 ;
28014 PyObject * obj1 = 0 ;
28015 char * kwnames[] = {
28016 (char *) "self",(char *) "check", NULL
28017 };
28018
28019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
28020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28021 if (!SWIG_IsOK(res1)) {
28022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28023 }
28024 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28025 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28026 if (!SWIG_IsOK(ecode2)) {
28027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
28028 }
28029 arg2 = static_cast< bool >(val2);
28030 {
28031 PyThreadState* __tstate = wxPyBeginAllowThreads();
28032 (arg1)->Check(arg2);
28033 wxPyEndAllowThreads(__tstate);
28034 if (PyErr_Occurred()) SWIG_fail;
28035 }
28036 resultobj = SWIG_Py_Void();
28037 return resultobj;
28038 fail:
28039 return NULL;
28040 }
28041
28042
28043 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28044 PyObject *resultobj = 0;
28045 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28046 bool arg2 ;
28047 void *argp1 = 0 ;
28048 int res1 = 0 ;
28049 bool val2 ;
28050 int ecode2 = 0 ;
28051 PyObject * obj0 = 0 ;
28052 PyObject * obj1 = 0 ;
28053 char * kwnames[] = {
28054 (char *) "self",(char *) "enable", NULL
28055 };
28056
28057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
28058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28059 if (!SWIG_IsOK(res1)) {
28060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28061 }
28062 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28063 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28064 if (!SWIG_IsOK(ecode2)) {
28065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
28066 }
28067 arg2 = static_cast< bool >(val2);
28068 {
28069 PyThreadState* __tstate = wxPyBeginAllowThreads();
28070 (arg1)->Enable(arg2);
28071 wxPyEndAllowThreads(__tstate);
28072 if (PyErr_Occurred()) SWIG_fail;
28073 }
28074 resultobj = SWIG_Py_Void();
28075 return resultobj;
28076 fail:
28077 return NULL;
28078 }
28079
28080
28081 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28082 PyObject *resultobj = 0;
28083 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28084 bool arg2 ;
28085 void *argp1 = 0 ;
28086 int res1 = 0 ;
28087 bool val2 ;
28088 int ecode2 = 0 ;
28089 PyObject * obj0 = 0 ;
28090 PyObject * obj1 = 0 ;
28091 char * kwnames[] = {
28092 (char *) "self",(char *) "show", NULL
28093 };
28094
28095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28097 if (!SWIG_IsOK(res1)) {
28098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28099 }
28100 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28101 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28102 if (!SWIG_IsOK(ecode2)) {
28103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28104 }
28105 arg2 = static_cast< bool >(val2);
28106 {
28107 PyThreadState* __tstate = wxPyBeginAllowThreads();
28108 (arg1)->Show(arg2);
28109 wxPyEndAllowThreads(__tstate);
28110 if (PyErr_Occurred()) SWIG_fail;
28111 }
28112 resultobj = SWIG_Py_Void();
28113 return resultobj;
28114 fail:
28115 return NULL;
28116 }
28117
28118
28119 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28120 PyObject *resultobj = 0;
28121 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28122 wxString *arg2 = 0 ;
28123 void *argp1 = 0 ;
28124 int res1 = 0 ;
28125 bool temp2 = false ;
28126 PyObject * obj0 = 0 ;
28127 PyObject * obj1 = 0 ;
28128 char * kwnames[] = {
28129 (char *) "self",(char *) "text", NULL
28130 };
28131
28132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28134 if (!SWIG_IsOK(res1)) {
28135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28136 }
28137 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28138 {
28139 arg2 = wxString_in_helper(obj1);
28140 if (arg2 == NULL) SWIG_fail;
28141 temp2 = true;
28142 }
28143 {
28144 PyThreadState* __tstate = wxPyBeginAllowThreads();
28145 (arg1)->SetText((wxString const &)*arg2);
28146 wxPyEndAllowThreads(__tstate);
28147 if (PyErr_Occurred()) SWIG_fail;
28148 }
28149 resultobj = SWIG_Py_Void();
28150 {
28151 if (temp2)
28152 delete arg2;
28153 }
28154 return resultobj;
28155 fail:
28156 {
28157 if (temp2)
28158 delete arg2;
28159 }
28160 return NULL;
28161 }
28162
28163
28164 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28165 PyObject *resultobj = 0;
28166 long arg1 ;
28167 long val1 ;
28168 int ecode1 = 0 ;
28169 PyObject * obj0 = 0 ;
28170 char * kwnames[] = {
28171 (char *) "updateInterval", NULL
28172 };
28173
28174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28175 ecode1 = SWIG_AsVal_long(obj0, &val1);
28176 if (!SWIG_IsOK(ecode1)) {
28177 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28178 }
28179 arg1 = static_cast< long >(val1);
28180 {
28181 PyThreadState* __tstate = wxPyBeginAllowThreads();
28182 wxUpdateUIEvent::SetUpdateInterval(arg1);
28183 wxPyEndAllowThreads(__tstate);
28184 if (PyErr_Occurred()) SWIG_fail;
28185 }
28186 resultobj = SWIG_Py_Void();
28187 return resultobj;
28188 fail:
28189 return NULL;
28190 }
28191
28192
28193 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28194 PyObject *resultobj = 0;
28195 long result;
28196
28197 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28198 {
28199 PyThreadState* __tstate = wxPyBeginAllowThreads();
28200 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28201 wxPyEndAllowThreads(__tstate);
28202 if (PyErr_Occurred()) SWIG_fail;
28203 }
28204 resultobj = SWIG_From_long(static_cast< long >(result));
28205 return resultobj;
28206 fail:
28207 return NULL;
28208 }
28209
28210
28211 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28212 PyObject *resultobj = 0;
28213 wxWindow *arg1 = (wxWindow *) 0 ;
28214 bool result;
28215 void *argp1 = 0 ;
28216 int res1 = 0 ;
28217 PyObject * obj0 = 0 ;
28218 char * kwnames[] = {
28219 (char *) "win", NULL
28220 };
28221
28222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28224 if (!SWIG_IsOK(res1)) {
28225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28226 }
28227 arg1 = reinterpret_cast< wxWindow * >(argp1);
28228 {
28229 PyThreadState* __tstate = wxPyBeginAllowThreads();
28230 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28231 wxPyEndAllowThreads(__tstate);
28232 if (PyErr_Occurred()) SWIG_fail;
28233 }
28234 {
28235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28236 }
28237 return resultobj;
28238 fail:
28239 return NULL;
28240 }
28241
28242
28243 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28244 PyObject *resultobj = 0;
28245
28246 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28247 {
28248 PyThreadState* __tstate = wxPyBeginAllowThreads();
28249 wxUpdateUIEvent::ResetUpdateTime();
28250 wxPyEndAllowThreads(__tstate);
28251 if (PyErr_Occurred()) SWIG_fail;
28252 }
28253 resultobj = SWIG_Py_Void();
28254 return resultobj;
28255 fail:
28256 return NULL;
28257 }
28258
28259
28260 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28261 PyObject *resultobj = 0;
28262 wxUpdateUIMode arg1 ;
28263 int val1 ;
28264 int ecode1 = 0 ;
28265 PyObject * obj0 = 0 ;
28266 char * kwnames[] = {
28267 (char *) "mode", NULL
28268 };
28269
28270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28271 ecode1 = SWIG_AsVal_int(obj0, &val1);
28272 if (!SWIG_IsOK(ecode1)) {
28273 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28274 }
28275 arg1 = static_cast< wxUpdateUIMode >(val1);
28276 {
28277 PyThreadState* __tstate = wxPyBeginAllowThreads();
28278 wxUpdateUIEvent::SetMode(arg1);
28279 wxPyEndAllowThreads(__tstate);
28280 if (PyErr_Occurred()) SWIG_fail;
28281 }
28282 resultobj = SWIG_Py_Void();
28283 return resultobj;
28284 fail:
28285 return NULL;
28286 }
28287
28288
28289 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28290 PyObject *resultobj = 0;
28291 wxUpdateUIMode result;
28292
28293 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28294 {
28295 PyThreadState* __tstate = wxPyBeginAllowThreads();
28296 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28297 wxPyEndAllowThreads(__tstate);
28298 if (PyErr_Occurred()) SWIG_fail;
28299 }
28300 resultobj = SWIG_From_int(static_cast< int >(result));
28301 return resultobj;
28302 fail:
28303 return NULL;
28304 }
28305
28306
28307 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28308 PyObject *obj;
28309 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28310 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28311 return SWIG_Py_Void();
28312 }
28313
28314 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28315 return SWIG_Python_InitShadowInstance(args);
28316 }
28317
28318 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28319 PyObject *resultobj = 0;
28320 wxSysColourChangedEvent *result = 0 ;
28321
28322 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28323 {
28324 PyThreadState* __tstate = wxPyBeginAllowThreads();
28325 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28326 wxPyEndAllowThreads(__tstate);
28327 if (PyErr_Occurred()) SWIG_fail;
28328 }
28329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28330 return resultobj;
28331 fail:
28332 return NULL;
28333 }
28334
28335
28336 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28337 PyObject *obj;
28338 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28339 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28340 return SWIG_Py_Void();
28341 }
28342
28343 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28344 return SWIG_Python_InitShadowInstance(args);
28345 }
28346
28347 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28348 PyObject *resultobj = 0;
28349 int arg1 = (int) 0 ;
28350 wxWindow *arg2 = (wxWindow *) NULL ;
28351 wxMouseCaptureChangedEvent *result = 0 ;
28352 int val1 ;
28353 int ecode1 = 0 ;
28354 void *argp2 = 0 ;
28355 int res2 = 0 ;
28356 PyObject * obj0 = 0 ;
28357 PyObject * obj1 = 0 ;
28358 char * kwnames[] = {
28359 (char *) "winid",(char *) "gainedCapture", NULL
28360 };
28361
28362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28363 if (obj0) {
28364 ecode1 = SWIG_AsVal_int(obj0, &val1);
28365 if (!SWIG_IsOK(ecode1)) {
28366 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28367 }
28368 arg1 = static_cast< int >(val1);
28369 }
28370 if (obj1) {
28371 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28372 if (!SWIG_IsOK(res2)) {
28373 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28374 }
28375 arg2 = reinterpret_cast< wxWindow * >(argp2);
28376 }
28377 {
28378 PyThreadState* __tstate = wxPyBeginAllowThreads();
28379 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28380 wxPyEndAllowThreads(__tstate);
28381 if (PyErr_Occurred()) SWIG_fail;
28382 }
28383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28384 return resultobj;
28385 fail:
28386 return NULL;
28387 }
28388
28389
28390 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28391 PyObject *resultobj = 0;
28392 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28393 wxWindow *result = 0 ;
28394 void *argp1 = 0 ;
28395 int res1 = 0 ;
28396 PyObject *swig_obj[1] ;
28397
28398 if (!args) SWIG_fail;
28399 swig_obj[0] = args;
28400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28401 if (!SWIG_IsOK(res1)) {
28402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28403 }
28404 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28405 {
28406 PyThreadState* __tstate = wxPyBeginAllowThreads();
28407 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28408 wxPyEndAllowThreads(__tstate);
28409 if (PyErr_Occurred()) SWIG_fail;
28410 }
28411 {
28412 resultobj = wxPyMake_wxObject(result, (bool)0);
28413 }
28414 return resultobj;
28415 fail:
28416 return NULL;
28417 }
28418
28419
28420 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28421 PyObject *obj;
28422 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28423 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28424 return SWIG_Py_Void();
28425 }
28426
28427 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28428 return SWIG_Python_InitShadowInstance(args);
28429 }
28430
28431 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28432 PyObject *resultobj = 0;
28433 int arg1 = (int) 0 ;
28434 wxMouseCaptureLostEvent *result = 0 ;
28435 int val1 ;
28436 int ecode1 = 0 ;
28437 PyObject * obj0 = 0 ;
28438 char * kwnames[] = {
28439 (char *) "winid", NULL
28440 };
28441
28442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28443 if (obj0) {
28444 ecode1 = SWIG_AsVal_int(obj0, &val1);
28445 if (!SWIG_IsOK(ecode1)) {
28446 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28447 }
28448 arg1 = static_cast< int >(val1);
28449 }
28450 {
28451 PyThreadState* __tstate = wxPyBeginAllowThreads();
28452 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28453 wxPyEndAllowThreads(__tstate);
28454 if (PyErr_Occurred()) SWIG_fail;
28455 }
28456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28457 return resultobj;
28458 fail:
28459 return NULL;
28460 }
28461
28462
28463 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28464 PyObject *obj;
28465 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28466 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28467 return SWIG_Py_Void();
28468 }
28469
28470 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28471 return SWIG_Python_InitShadowInstance(args);
28472 }
28473
28474 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28475 PyObject *resultobj = 0;
28476 wxDisplayChangedEvent *result = 0 ;
28477
28478 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28479 {
28480 PyThreadState* __tstate = wxPyBeginAllowThreads();
28481 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28482 wxPyEndAllowThreads(__tstate);
28483 if (PyErr_Occurred()) SWIG_fail;
28484 }
28485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28486 return resultobj;
28487 fail:
28488 return NULL;
28489 }
28490
28491
28492 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28493 PyObject *obj;
28494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28495 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28496 return SWIG_Py_Void();
28497 }
28498
28499 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28500 return SWIG_Python_InitShadowInstance(args);
28501 }
28502
28503 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28504 PyObject *resultobj = 0;
28505 int arg1 = (int) 0 ;
28506 wxPaletteChangedEvent *result = 0 ;
28507 int val1 ;
28508 int ecode1 = 0 ;
28509 PyObject * obj0 = 0 ;
28510 char * kwnames[] = {
28511 (char *) "id", NULL
28512 };
28513
28514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28515 if (obj0) {
28516 ecode1 = SWIG_AsVal_int(obj0, &val1);
28517 if (!SWIG_IsOK(ecode1)) {
28518 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28519 }
28520 arg1 = static_cast< int >(val1);
28521 }
28522 {
28523 PyThreadState* __tstate = wxPyBeginAllowThreads();
28524 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28525 wxPyEndAllowThreads(__tstate);
28526 if (PyErr_Occurred()) SWIG_fail;
28527 }
28528 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28529 return resultobj;
28530 fail:
28531 return NULL;
28532 }
28533
28534
28535 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28536 PyObject *resultobj = 0;
28537 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28538 wxWindow *arg2 = (wxWindow *) 0 ;
28539 void *argp1 = 0 ;
28540 int res1 = 0 ;
28541 void *argp2 = 0 ;
28542 int res2 = 0 ;
28543 PyObject * obj0 = 0 ;
28544 PyObject * obj1 = 0 ;
28545 char * kwnames[] = {
28546 (char *) "self",(char *) "win", NULL
28547 };
28548
28549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28551 if (!SWIG_IsOK(res1)) {
28552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28553 }
28554 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28555 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28556 if (!SWIG_IsOK(res2)) {
28557 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28558 }
28559 arg2 = reinterpret_cast< wxWindow * >(argp2);
28560 {
28561 PyThreadState* __tstate = wxPyBeginAllowThreads();
28562 (arg1)->SetChangedWindow(arg2);
28563 wxPyEndAllowThreads(__tstate);
28564 if (PyErr_Occurred()) SWIG_fail;
28565 }
28566 resultobj = SWIG_Py_Void();
28567 return resultobj;
28568 fail:
28569 return NULL;
28570 }
28571
28572
28573 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28574 PyObject *resultobj = 0;
28575 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28576 wxWindow *result = 0 ;
28577 void *argp1 = 0 ;
28578 int res1 = 0 ;
28579 PyObject *swig_obj[1] ;
28580
28581 if (!args) SWIG_fail;
28582 swig_obj[0] = args;
28583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28584 if (!SWIG_IsOK(res1)) {
28585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28586 }
28587 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28588 {
28589 PyThreadState* __tstate = wxPyBeginAllowThreads();
28590 result = (wxWindow *)(arg1)->GetChangedWindow();
28591 wxPyEndAllowThreads(__tstate);
28592 if (PyErr_Occurred()) SWIG_fail;
28593 }
28594 {
28595 resultobj = wxPyMake_wxObject(result, (bool)0);
28596 }
28597 return resultobj;
28598 fail:
28599 return NULL;
28600 }
28601
28602
28603 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28604 PyObject *obj;
28605 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28606 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28607 return SWIG_Py_Void();
28608 }
28609
28610 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28611 return SWIG_Python_InitShadowInstance(args);
28612 }
28613
28614 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28615 PyObject *resultobj = 0;
28616 int arg1 = (int) 0 ;
28617 wxQueryNewPaletteEvent *result = 0 ;
28618 int val1 ;
28619 int ecode1 = 0 ;
28620 PyObject * obj0 = 0 ;
28621 char * kwnames[] = {
28622 (char *) "winid", NULL
28623 };
28624
28625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28626 if (obj0) {
28627 ecode1 = SWIG_AsVal_int(obj0, &val1);
28628 if (!SWIG_IsOK(ecode1)) {
28629 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28630 }
28631 arg1 = static_cast< int >(val1);
28632 }
28633 {
28634 PyThreadState* __tstate = wxPyBeginAllowThreads();
28635 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28636 wxPyEndAllowThreads(__tstate);
28637 if (PyErr_Occurred()) SWIG_fail;
28638 }
28639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28640 return resultobj;
28641 fail:
28642 return NULL;
28643 }
28644
28645
28646 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28647 PyObject *resultobj = 0;
28648 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28649 bool arg2 ;
28650 void *argp1 = 0 ;
28651 int res1 = 0 ;
28652 bool val2 ;
28653 int ecode2 = 0 ;
28654 PyObject * obj0 = 0 ;
28655 PyObject * obj1 = 0 ;
28656 char * kwnames[] = {
28657 (char *) "self",(char *) "realized", NULL
28658 };
28659
28660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28662 if (!SWIG_IsOK(res1)) {
28663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28664 }
28665 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28666 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28667 if (!SWIG_IsOK(ecode2)) {
28668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28669 }
28670 arg2 = static_cast< bool >(val2);
28671 {
28672 PyThreadState* __tstate = wxPyBeginAllowThreads();
28673 (arg1)->SetPaletteRealized(arg2);
28674 wxPyEndAllowThreads(__tstate);
28675 if (PyErr_Occurred()) SWIG_fail;
28676 }
28677 resultobj = SWIG_Py_Void();
28678 return resultobj;
28679 fail:
28680 return NULL;
28681 }
28682
28683
28684 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28685 PyObject *resultobj = 0;
28686 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28687 bool result;
28688 void *argp1 = 0 ;
28689 int res1 = 0 ;
28690 PyObject *swig_obj[1] ;
28691
28692 if (!args) SWIG_fail;
28693 swig_obj[0] = args;
28694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28695 if (!SWIG_IsOK(res1)) {
28696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28697 }
28698 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28699 {
28700 PyThreadState* __tstate = wxPyBeginAllowThreads();
28701 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28702 wxPyEndAllowThreads(__tstate);
28703 if (PyErr_Occurred()) SWIG_fail;
28704 }
28705 {
28706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28707 }
28708 return resultobj;
28709 fail:
28710 return NULL;
28711 }
28712
28713
28714 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28715 PyObject *obj;
28716 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28717 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28718 return SWIG_Py_Void();
28719 }
28720
28721 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28722 return SWIG_Python_InitShadowInstance(args);
28723 }
28724
28725 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28726 PyObject *resultobj = 0;
28727 wxNavigationKeyEvent *result = 0 ;
28728
28729 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28730 {
28731 PyThreadState* __tstate = wxPyBeginAllowThreads();
28732 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28733 wxPyEndAllowThreads(__tstate);
28734 if (PyErr_Occurred()) SWIG_fail;
28735 }
28736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28737 return resultobj;
28738 fail:
28739 return NULL;
28740 }
28741
28742
28743 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28744 PyObject *resultobj = 0;
28745 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28746 bool result;
28747 void *argp1 = 0 ;
28748 int res1 = 0 ;
28749 PyObject *swig_obj[1] ;
28750
28751 if (!args) SWIG_fail;
28752 swig_obj[0] = args;
28753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28754 if (!SWIG_IsOK(res1)) {
28755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28756 }
28757 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28758 {
28759 PyThreadState* __tstate = wxPyBeginAllowThreads();
28760 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28761 wxPyEndAllowThreads(__tstate);
28762 if (PyErr_Occurred()) SWIG_fail;
28763 }
28764 {
28765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28766 }
28767 return resultobj;
28768 fail:
28769 return NULL;
28770 }
28771
28772
28773 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28774 PyObject *resultobj = 0;
28775 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28776 bool arg2 ;
28777 void *argp1 = 0 ;
28778 int res1 = 0 ;
28779 bool val2 ;
28780 int ecode2 = 0 ;
28781 PyObject * obj0 = 0 ;
28782 PyObject * obj1 = 0 ;
28783 char * kwnames[] = {
28784 (char *) "self",(char *) "forward", NULL
28785 };
28786
28787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28789 if (!SWIG_IsOK(res1)) {
28790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28791 }
28792 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28793 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28794 if (!SWIG_IsOK(ecode2)) {
28795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28796 }
28797 arg2 = static_cast< bool >(val2);
28798 {
28799 PyThreadState* __tstate = wxPyBeginAllowThreads();
28800 (arg1)->SetDirection(arg2);
28801 wxPyEndAllowThreads(__tstate);
28802 if (PyErr_Occurred()) SWIG_fail;
28803 }
28804 resultobj = SWIG_Py_Void();
28805 return resultobj;
28806 fail:
28807 return NULL;
28808 }
28809
28810
28811 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28812 PyObject *resultobj = 0;
28813 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28814 bool result;
28815 void *argp1 = 0 ;
28816 int res1 = 0 ;
28817 PyObject *swig_obj[1] ;
28818
28819 if (!args) SWIG_fail;
28820 swig_obj[0] = args;
28821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28822 if (!SWIG_IsOK(res1)) {
28823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28824 }
28825 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28826 {
28827 PyThreadState* __tstate = wxPyBeginAllowThreads();
28828 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28829 wxPyEndAllowThreads(__tstate);
28830 if (PyErr_Occurred()) SWIG_fail;
28831 }
28832 {
28833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28834 }
28835 return resultobj;
28836 fail:
28837 return NULL;
28838 }
28839
28840
28841 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28842 PyObject *resultobj = 0;
28843 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28844 bool arg2 ;
28845 void *argp1 = 0 ;
28846 int res1 = 0 ;
28847 bool val2 ;
28848 int ecode2 = 0 ;
28849 PyObject * obj0 = 0 ;
28850 PyObject * obj1 = 0 ;
28851 char * kwnames[] = {
28852 (char *) "self",(char *) "ischange", NULL
28853 };
28854
28855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28857 if (!SWIG_IsOK(res1)) {
28858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28859 }
28860 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28861 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28862 if (!SWIG_IsOK(ecode2)) {
28863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28864 }
28865 arg2 = static_cast< bool >(val2);
28866 {
28867 PyThreadState* __tstate = wxPyBeginAllowThreads();
28868 (arg1)->SetWindowChange(arg2);
28869 wxPyEndAllowThreads(__tstate);
28870 if (PyErr_Occurred()) SWIG_fail;
28871 }
28872 resultobj = SWIG_Py_Void();
28873 return resultobj;
28874 fail:
28875 return NULL;
28876 }
28877
28878
28879 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28880 PyObject *resultobj = 0;
28881 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28882 bool result;
28883 void *argp1 = 0 ;
28884 int res1 = 0 ;
28885 PyObject *swig_obj[1] ;
28886
28887 if (!args) SWIG_fail;
28888 swig_obj[0] = args;
28889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28890 if (!SWIG_IsOK(res1)) {
28891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28892 }
28893 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28894 {
28895 PyThreadState* __tstate = wxPyBeginAllowThreads();
28896 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28897 wxPyEndAllowThreads(__tstate);
28898 if (PyErr_Occurred()) SWIG_fail;
28899 }
28900 {
28901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28902 }
28903 return resultobj;
28904 fail:
28905 return NULL;
28906 }
28907
28908
28909 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28910 PyObject *resultobj = 0;
28911 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28912 bool arg2 ;
28913 void *argp1 = 0 ;
28914 int res1 = 0 ;
28915 bool val2 ;
28916 int ecode2 = 0 ;
28917 PyObject * obj0 = 0 ;
28918 PyObject * obj1 = 0 ;
28919 char * kwnames[] = {
28920 (char *) "self",(char *) "bIs", NULL
28921 };
28922
28923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28925 if (!SWIG_IsOK(res1)) {
28926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28927 }
28928 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28929 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28930 if (!SWIG_IsOK(ecode2)) {
28931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28932 }
28933 arg2 = static_cast< bool >(val2);
28934 {
28935 PyThreadState* __tstate = wxPyBeginAllowThreads();
28936 (arg1)->SetFromTab(arg2);
28937 wxPyEndAllowThreads(__tstate);
28938 if (PyErr_Occurred()) SWIG_fail;
28939 }
28940 resultobj = SWIG_Py_Void();
28941 return resultobj;
28942 fail:
28943 return NULL;
28944 }
28945
28946
28947 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28948 PyObject *resultobj = 0;
28949 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28950 long arg2 ;
28951 void *argp1 = 0 ;
28952 int res1 = 0 ;
28953 long val2 ;
28954 int ecode2 = 0 ;
28955 PyObject * obj0 = 0 ;
28956 PyObject * obj1 = 0 ;
28957 char * kwnames[] = {
28958 (char *) "self",(char *) "flags", NULL
28959 };
28960
28961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28963 if (!SWIG_IsOK(res1)) {
28964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28965 }
28966 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28967 ecode2 = SWIG_AsVal_long(obj1, &val2);
28968 if (!SWIG_IsOK(ecode2)) {
28969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28970 }
28971 arg2 = static_cast< long >(val2);
28972 {
28973 PyThreadState* __tstate = wxPyBeginAllowThreads();
28974 (arg1)->SetFlags(arg2);
28975 wxPyEndAllowThreads(__tstate);
28976 if (PyErr_Occurred()) SWIG_fail;
28977 }
28978 resultobj = SWIG_Py_Void();
28979 return resultobj;
28980 fail:
28981 return NULL;
28982 }
28983
28984
28985 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28986 PyObject *resultobj = 0;
28987 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28988 wxWindow *result = 0 ;
28989 void *argp1 = 0 ;
28990 int res1 = 0 ;
28991 PyObject *swig_obj[1] ;
28992
28993 if (!args) SWIG_fail;
28994 swig_obj[0] = args;
28995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28996 if (!SWIG_IsOK(res1)) {
28997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28998 }
28999 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29000 {
29001 PyThreadState* __tstate = wxPyBeginAllowThreads();
29002 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
29003 wxPyEndAllowThreads(__tstate);
29004 if (PyErr_Occurred()) SWIG_fail;
29005 }
29006 {
29007 resultobj = wxPyMake_wxObject(result, (bool)0);
29008 }
29009 return resultobj;
29010 fail:
29011 return NULL;
29012 }
29013
29014
29015 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29016 PyObject *resultobj = 0;
29017 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29018 wxWindow *arg2 = (wxWindow *) 0 ;
29019 void *argp1 = 0 ;
29020 int res1 = 0 ;
29021 void *argp2 = 0 ;
29022 int res2 = 0 ;
29023 PyObject * obj0 = 0 ;
29024 PyObject * obj1 = 0 ;
29025 char * kwnames[] = {
29026 (char *) "self",(char *) "win", NULL
29027 };
29028
29029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
29030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29031 if (!SWIG_IsOK(res1)) {
29032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29033 }
29034 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29035 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29036 if (!SWIG_IsOK(res2)) {
29037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
29038 }
29039 arg2 = reinterpret_cast< wxWindow * >(argp2);
29040 {
29041 PyThreadState* __tstate = wxPyBeginAllowThreads();
29042 (arg1)->SetCurrentFocus(arg2);
29043 wxPyEndAllowThreads(__tstate);
29044 if (PyErr_Occurred()) SWIG_fail;
29045 }
29046 resultobj = SWIG_Py_Void();
29047 return resultobj;
29048 fail:
29049 return NULL;
29050 }
29051
29052
29053 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29054 PyObject *obj;
29055 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29056 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
29057 return SWIG_Py_Void();
29058 }
29059
29060 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29061 return SWIG_Python_InitShadowInstance(args);
29062 }
29063
29064 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29065 PyObject *resultobj = 0;
29066 wxWindow *arg1 = (wxWindow *) NULL ;
29067 wxWindowCreateEvent *result = 0 ;
29068 void *argp1 = 0 ;
29069 int res1 = 0 ;
29070 PyObject * obj0 = 0 ;
29071 char * kwnames[] = {
29072 (char *) "win", NULL
29073 };
29074
29075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
29076 if (obj0) {
29077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29078 if (!SWIG_IsOK(res1)) {
29079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29080 }
29081 arg1 = reinterpret_cast< wxWindow * >(argp1);
29082 }
29083 {
29084 PyThreadState* __tstate = wxPyBeginAllowThreads();
29085 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29086 wxPyEndAllowThreads(__tstate);
29087 if (PyErr_Occurred()) SWIG_fail;
29088 }
29089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29090 return resultobj;
29091 fail:
29092 return NULL;
29093 }
29094
29095
29096 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29097 PyObject *resultobj = 0;
29098 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29099 wxWindow *result = 0 ;
29100 void *argp1 = 0 ;
29101 int res1 = 0 ;
29102 PyObject *swig_obj[1] ;
29103
29104 if (!args) SWIG_fail;
29105 swig_obj[0] = args;
29106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29107 if (!SWIG_IsOK(res1)) {
29108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29109 }
29110 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29111 {
29112 PyThreadState* __tstate = wxPyBeginAllowThreads();
29113 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29114 wxPyEndAllowThreads(__tstate);
29115 if (PyErr_Occurred()) SWIG_fail;
29116 }
29117 {
29118 resultobj = wxPyMake_wxObject(result, (bool)0);
29119 }
29120 return resultobj;
29121 fail:
29122 return NULL;
29123 }
29124
29125
29126 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29127 PyObject *obj;
29128 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29129 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29130 return SWIG_Py_Void();
29131 }
29132
29133 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29134 return SWIG_Python_InitShadowInstance(args);
29135 }
29136
29137 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29138 PyObject *resultobj = 0;
29139 wxWindow *arg1 = (wxWindow *) NULL ;
29140 wxWindowDestroyEvent *result = 0 ;
29141 void *argp1 = 0 ;
29142 int res1 = 0 ;
29143 PyObject * obj0 = 0 ;
29144 char * kwnames[] = {
29145 (char *) "win", NULL
29146 };
29147
29148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29149 if (obj0) {
29150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29151 if (!SWIG_IsOK(res1)) {
29152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29153 }
29154 arg1 = reinterpret_cast< wxWindow * >(argp1);
29155 }
29156 {
29157 PyThreadState* __tstate = wxPyBeginAllowThreads();
29158 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29159 wxPyEndAllowThreads(__tstate);
29160 if (PyErr_Occurred()) SWIG_fail;
29161 }
29162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29163 return resultobj;
29164 fail:
29165 return NULL;
29166 }
29167
29168
29169 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29170 PyObject *resultobj = 0;
29171 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29172 wxWindow *result = 0 ;
29173 void *argp1 = 0 ;
29174 int res1 = 0 ;
29175 PyObject *swig_obj[1] ;
29176
29177 if (!args) SWIG_fail;
29178 swig_obj[0] = args;
29179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29180 if (!SWIG_IsOK(res1)) {
29181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29182 }
29183 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29184 {
29185 PyThreadState* __tstate = wxPyBeginAllowThreads();
29186 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29187 wxPyEndAllowThreads(__tstate);
29188 if (PyErr_Occurred()) SWIG_fail;
29189 }
29190 {
29191 resultobj = wxPyMake_wxObject(result, (bool)0);
29192 }
29193 return resultobj;
29194 fail:
29195 return NULL;
29196 }
29197
29198
29199 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29200 PyObject *obj;
29201 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29202 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29203 return SWIG_Py_Void();
29204 }
29205
29206 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29207 return SWIG_Python_InitShadowInstance(args);
29208 }
29209
29210 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29211 PyObject *resultobj = 0;
29212 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29213 int arg2 = (int) 0 ;
29214 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29215 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29216 wxContextMenuEvent *result = 0 ;
29217 int val1 ;
29218 int ecode1 = 0 ;
29219 int val2 ;
29220 int ecode2 = 0 ;
29221 wxPoint temp3 ;
29222 PyObject * obj0 = 0 ;
29223 PyObject * obj1 = 0 ;
29224 PyObject * obj2 = 0 ;
29225 char * kwnames[] = {
29226 (char *) "type",(char *) "winid",(char *) "pt", NULL
29227 };
29228
29229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29230 if (obj0) {
29231 ecode1 = SWIG_AsVal_int(obj0, &val1);
29232 if (!SWIG_IsOK(ecode1)) {
29233 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29234 }
29235 arg1 = static_cast< wxEventType >(val1);
29236 }
29237 if (obj1) {
29238 ecode2 = SWIG_AsVal_int(obj1, &val2);
29239 if (!SWIG_IsOK(ecode2)) {
29240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29241 }
29242 arg2 = static_cast< int >(val2);
29243 }
29244 if (obj2) {
29245 {
29246 arg3 = &temp3;
29247 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29248 }
29249 }
29250 {
29251 PyThreadState* __tstate = wxPyBeginAllowThreads();
29252 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29253 wxPyEndAllowThreads(__tstate);
29254 if (PyErr_Occurred()) SWIG_fail;
29255 }
29256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29257 return resultobj;
29258 fail:
29259 return NULL;
29260 }
29261
29262
29263 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29264 PyObject *resultobj = 0;
29265 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29266 wxPoint *result = 0 ;
29267 void *argp1 = 0 ;
29268 int res1 = 0 ;
29269 PyObject *swig_obj[1] ;
29270
29271 if (!args) SWIG_fail;
29272 swig_obj[0] = args;
29273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29274 if (!SWIG_IsOK(res1)) {
29275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29276 }
29277 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29278 {
29279 PyThreadState* __tstate = wxPyBeginAllowThreads();
29280 {
29281 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29282 result = (wxPoint *) &_result_ref;
29283 }
29284 wxPyEndAllowThreads(__tstate);
29285 if (PyErr_Occurred()) SWIG_fail;
29286 }
29287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29288 return resultobj;
29289 fail:
29290 return NULL;
29291 }
29292
29293
29294 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29295 PyObject *resultobj = 0;
29296 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29297 wxPoint *arg2 = 0 ;
29298 void *argp1 = 0 ;
29299 int res1 = 0 ;
29300 wxPoint temp2 ;
29301 PyObject * obj0 = 0 ;
29302 PyObject * obj1 = 0 ;
29303 char * kwnames[] = {
29304 (char *) "self",(char *) "pos", NULL
29305 };
29306
29307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29309 if (!SWIG_IsOK(res1)) {
29310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29311 }
29312 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29313 {
29314 arg2 = &temp2;
29315 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29316 }
29317 {
29318 PyThreadState* __tstate = wxPyBeginAllowThreads();
29319 (arg1)->SetPosition((wxPoint const &)*arg2);
29320 wxPyEndAllowThreads(__tstate);
29321 if (PyErr_Occurred()) SWIG_fail;
29322 }
29323 resultobj = SWIG_Py_Void();
29324 return resultobj;
29325 fail:
29326 return NULL;
29327 }
29328
29329
29330 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29331 PyObject *obj;
29332 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29333 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29334 return SWIG_Py_Void();
29335 }
29336
29337 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29338 return SWIG_Python_InitShadowInstance(args);
29339 }
29340
29341 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29342 PyObject *resultobj = 0;
29343 wxIdleEvent *result = 0 ;
29344
29345 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29346 {
29347 PyThreadState* __tstate = wxPyBeginAllowThreads();
29348 result = (wxIdleEvent *)new wxIdleEvent();
29349 wxPyEndAllowThreads(__tstate);
29350 if (PyErr_Occurred()) SWIG_fail;
29351 }
29352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29353 return resultobj;
29354 fail:
29355 return NULL;
29356 }
29357
29358
29359 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29360 PyObject *resultobj = 0;
29361 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29362 bool arg2 = (bool) true ;
29363 void *argp1 = 0 ;
29364 int res1 = 0 ;
29365 bool val2 ;
29366 int ecode2 = 0 ;
29367 PyObject * obj0 = 0 ;
29368 PyObject * obj1 = 0 ;
29369 char * kwnames[] = {
29370 (char *) "self",(char *) "needMore", NULL
29371 };
29372
29373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29375 if (!SWIG_IsOK(res1)) {
29376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29377 }
29378 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29379 if (obj1) {
29380 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29381 if (!SWIG_IsOK(ecode2)) {
29382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29383 }
29384 arg2 = static_cast< bool >(val2);
29385 }
29386 {
29387 PyThreadState* __tstate = wxPyBeginAllowThreads();
29388 (arg1)->RequestMore(arg2);
29389 wxPyEndAllowThreads(__tstate);
29390 if (PyErr_Occurred()) SWIG_fail;
29391 }
29392 resultobj = SWIG_Py_Void();
29393 return resultobj;
29394 fail:
29395 return NULL;
29396 }
29397
29398
29399 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29400 PyObject *resultobj = 0;
29401 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29402 bool result;
29403 void *argp1 = 0 ;
29404 int res1 = 0 ;
29405 PyObject *swig_obj[1] ;
29406
29407 if (!args) SWIG_fail;
29408 swig_obj[0] = args;
29409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29410 if (!SWIG_IsOK(res1)) {
29411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29412 }
29413 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29414 {
29415 PyThreadState* __tstate = wxPyBeginAllowThreads();
29416 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29417 wxPyEndAllowThreads(__tstate);
29418 if (PyErr_Occurred()) SWIG_fail;
29419 }
29420 {
29421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29422 }
29423 return resultobj;
29424 fail:
29425 return NULL;
29426 }
29427
29428
29429 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29430 PyObject *resultobj = 0;
29431 wxIdleMode arg1 ;
29432 int val1 ;
29433 int ecode1 = 0 ;
29434 PyObject * obj0 = 0 ;
29435 char * kwnames[] = {
29436 (char *) "mode", NULL
29437 };
29438
29439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29440 ecode1 = SWIG_AsVal_int(obj0, &val1);
29441 if (!SWIG_IsOK(ecode1)) {
29442 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29443 }
29444 arg1 = static_cast< wxIdleMode >(val1);
29445 {
29446 PyThreadState* __tstate = wxPyBeginAllowThreads();
29447 wxIdleEvent::SetMode(arg1);
29448 wxPyEndAllowThreads(__tstate);
29449 if (PyErr_Occurred()) SWIG_fail;
29450 }
29451 resultobj = SWIG_Py_Void();
29452 return resultobj;
29453 fail:
29454 return NULL;
29455 }
29456
29457
29458 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29459 PyObject *resultobj = 0;
29460 wxIdleMode result;
29461
29462 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29463 {
29464 PyThreadState* __tstate = wxPyBeginAllowThreads();
29465 result = (wxIdleMode)wxIdleEvent::GetMode();
29466 wxPyEndAllowThreads(__tstate);
29467 if (PyErr_Occurred()) SWIG_fail;
29468 }
29469 resultobj = SWIG_From_int(static_cast< int >(result));
29470 return resultobj;
29471 fail:
29472 return NULL;
29473 }
29474
29475
29476 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29477 PyObject *resultobj = 0;
29478 wxWindow *arg1 = (wxWindow *) 0 ;
29479 bool result;
29480 void *argp1 = 0 ;
29481 int res1 = 0 ;
29482 PyObject * obj0 = 0 ;
29483 char * kwnames[] = {
29484 (char *) "win", NULL
29485 };
29486
29487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29489 if (!SWIG_IsOK(res1)) {
29490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29491 }
29492 arg1 = reinterpret_cast< wxWindow * >(argp1);
29493 {
29494 PyThreadState* __tstate = wxPyBeginAllowThreads();
29495 result = (bool)wxIdleEvent::CanSend(arg1);
29496 wxPyEndAllowThreads(__tstate);
29497 if (PyErr_Occurred()) SWIG_fail;
29498 }
29499 {
29500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29501 }
29502 return resultobj;
29503 fail:
29504 return NULL;
29505 }
29506
29507
29508 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29509 PyObject *obj;
29510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29511 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29512 return SWIG_Py_Void();
29513 }
29514
29515 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29516 return SWIG_Python_InitShadowInstance(args);
29517 }
29518
29519 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29520 PyObject *resultobj = 0;
29521 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29522 int arg2 = (int) 0 ;
29523 wxClipboardTextEvent *result = 0 ;
29524 int val1 ;
29525 int ecode1 = 0 ;
29526 int val2 ;
29527 int ecode2 = 0 ;
29528 PyObject * obj0 = 0 ;
29529 PyObject * obj1 = 0 ;
29530 char * kwnames[] = {
29531 (char *) "type",(char *) "winid", NULL
29532 };
29533
29534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29535 if (obj0) {
29536 ecode1 = SWIG_AsVal_int(obj0, &val1);
29537 if (!SWIG_IsOK(ecode1)) {
29538 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29539 }
29540 arg1 = static_cast< wxEventType >(val1);
29541 }
29542 if (obj1) {
29543 ecode2 = SWIG_AsVal_int(obj1, &val2);
29544 if (!SWIG_IsOK(ecode2)) {
29545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29546 }
29547 arg2 = static_cast< int >(val2);
29548 }
29549 {
29550 PyThreadState* __tstate = wxPyBeginAllowThreads();
29551 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29552 wxPyEndAllowThreads(__tstate);
29553 if (PyErr_Occurred()) SWIG_fail;
29554 }
29555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29556 return resultobj;
29557 fail:
29558 return NULL;
29559 }
29560
29561
29562 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29563 PyObject *obj;
29564 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29565 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29566 return SWIG_Py_Void();
29567 }
29568
29569 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29570 return SWIG_Python_InitShadowInstance(args);
29571 }
29572
29573 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29574 PyObject *resultobj = 0;
29575 int arg1 = (int) 0 ;
29576 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29577 wxPyEvent *result = 0 ;
29578 int val1 ;
29579 int ecode1 = 0 ;
29580 int val2 ;
29581 int ecode2 = 0 ;
29582 PyObject * obj0 = 0 ;
29583 PyObject * obj1 = 0 ;
29584 char * kwnames[] = {
29585 (char *) "winid",(char *) "eventType", NULL
29586 };
29587
29588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29589 if (obj0) {
29590 ecode1 = SWIG_AsVal_int(obj0, &val1);
29591 if (!SWIG_IsOK(ecode1)) {
29592 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29593 }
29594 arg1 = static_cast< int >(val1);
29595 }
29596 if (obj1) {
29597 ecode2 = SWIG_AsVal_int(obj1, &val2);
29598 if (!SWIG_IsOK(ecode2)) {
29599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29600 }
29601 arg2 = static_cast< wxEventType >(val2);
29602 }
29603 {
29604 PyThreadState* __tstate = wxPyBeginAllowThreads();
29605 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29606 wxPyEndAllowThreads(__tstate);
29607 if (PyErr_Occurred()) SWIG_fail;
29608 }
29609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29610 return resultobj;
29611 fail:
29612 return NULL;
29613 }
29614
29615
29616 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29617 PyObject *resultobj = 0;
29618 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29619 void *argp1 = 0 ;
29620 int res1 = 0 ;
29621 PyObject *swig_obj[1] ;
29622
29623 if (!args) SWIG_fail;
29624 swig_obj[0] = args;
29625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29626 if (!SWIG_IsOK(res1)) {
29627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29628 }
29629 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29630 {
29631 PyThreadState* __tstate = wxPyBeginAllowThreads();
29632 delete arg1;
29633
29634 wxPyEndAllowThreads(__tstate);
29635 if (PyErr_Occurred()) SWIG_fail;
29636 }
29637 resultobj = SWIG_Py_Void();
29638 return resultobj;
29639 fail:
29640 return NULL;
29641 }
29642
29643
29644 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29645 PyObject *resultobj = 0;
29646 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29647 PyObject *arg2 = (PyObject *) 0 ;
29648 void *argp1 = 0 ;
29649 int res1 = 0 ;
29650 PyObject * obj0 = 0 ;
29651 PyObject * obj1 = 0 ;
29652 char * kwnames[] = {
29653 (char *) "self",(char *) "self", NULL
29654 };
29655
29656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29658 if (!SWIG_IsOK(res1)) {
29659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29660 }
29661 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29662 arg2 = obj1;
29663 {
29664 PyThreadState* __tstate = wxPyBeginAllowThreads();
29665 (arg1)->SetSelf(arg2);
29666 wxPyEndAllowThreads(__tstate);
29667 if (PyErr_Occurred()) SWIG_fail;
29668 }
29669 resultobj = SWIG_Py_Void();
29670 return resultobj;
29671 fail:
29672 return NULL;
29673 }
29674
29675
29676 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29677 PyObject *resultobj = 0;
29678 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29679 PyObject *result = 0 ;
29680 void *argp1 = 0 ;
29681 int res1 = 0 ;
29682 PyObject *swig_obj[1] ;
29683
29684 if (!args) SWIG_fail;
29685 swig_obj[0] = args;
29686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29687 if (!SWIG_IsOK(res1)) {
29688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29689 }
29690 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29691 {
29692 PyThreadState* __tstate = wxPyBeginAllowThreads();
29693 result = (PyObject *)(arg1)->GetSelf();
29694 wxPyEndAllowThreads(__tstate);
29695 if (PyErr_Occurred()) SWIG_fail;
29696 }
29697 resultobj = result;
29698 return resultobj;
29699 fail:
29700 return NULL;
29701 }
29702
29703
29704 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29705 PyObject *obj;
29706 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29707 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29708 return SWIG_Py_Void();
29709 }
29710
29711 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29712 return SWIG_Python_InitShadowInstance(args);
29713 }
29714
29715 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29716 PyObject *resultobj = 0;
29717 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29718 int arg2 = (int) 0 ;
29719 wxPyCommandEvent *result = 0 ;
29720 int val1 ;
29721 int ecode1 = 0 ;
29722 int val2 ;
29723 int ecode2 = 0 ;
29724 PyObject * obj0 = 0 ;
29725 PyObject * obj1 = 0 ;
29726 char * kwnames[] = {
29727 (char *) "eventType",(char *) "id", NULL
29728 };
29729
29730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29731 if (obj0) {
29732 ecode1 = SWIG_AsVal_int(obj0, &val1);
29733 if (!SWIG_IsOK(ecode1)) {
29734 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29735 }
29736 arg1 = static_cast< wxEventType >(val1);
29737 }
29738 if (obj1) {
29739 ecode2 = SWIG_AsVal_int(obj1, &val2);
29740 if (!SWIG_IsOK(ecode2)) {
29741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29742 }
29743 arg2 = static_cast< int >(val2);
29744 }
29745 {
29746 PyThreadState* __tstate = wxPyBeginAllowThreads();
29747 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29748 wxPyEndAllowThreads(__tstate);
29749 if (PyErr_Occurred()) SWIG_fail;
29750 }
29751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29752 return resultobj;
29753 fail:
29754 return NULL;
29755 }
29756
29757
29758 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29759 PyObject *resultobj = 0;
29760 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29761 void *argp1 = 0 ;
29762 int res1 = 0 ;
29763 PyObject *swig_obj[1] ;
29764
29765 if (!args) SWIG_fail;
29766 swig_obj[0] = args;
29767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29768 if (!SWIG_IsOK(res1)) {
29769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29770 }
29771 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29772 {
29773 PyThreadState* __tstate = wxPyBeginAllowThreads();
29774 delete arg1;
29775
29776 wxPyEndAllowThreads(__tstate);
29777 if (PyErr_Occurred()) SWIG_fail;
29778 }
29779 resultobj = SWIG_Py_Void();
29780 return resultobj;
29781 fail:
29782 return NULL;
29783 }
29784
29785
29786 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29787 PyObject *resultobj = 0;
29788 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29789 PyObject *arg2 = (PyObject *) 0 ;
29790 void *argp1 = 0 ;
29791 int res1 = 0 ;
29792 PyObject * obj0 = 0 ;
29793 PyObject * obj1 = 0 ;
29794 char * kwnames[] = {
29795 (char *) "self",(char *) "self", NULL
29796 };
29797
29798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29800 if (!SWIG_IsOK(res1)) {
29801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29802 }
29803 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29804 arg2 = obj1;
29805 {
29806 PyThreadState* __tstate = wxPyBeginAllowThreads();
29807 (arg1)->SetSelf(arg2);
29808 wxPyEndAllowThreads(__tstate);
29809 if (PyErr_Occurred()) SWIG_fail;
29810 }
29811 resultobj = SWIG_Py_Void();
29812 return resultobj;
29813 fail:
29814 return NULL;
29815 }
29816
29817
29818 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29819 PyObject *resultobj = 0;
29820 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29821 PyObject *result = 0 ;
29822 void *argp1 = 0 ;
29823 int res1 = 0 ;
29824 PyObject *swig_obj[1] ;
29825
29826 if (!args) SWIG_fail;
29827 swig_obj[0] = args;
29828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29829 if (!SWIG_IsOK(res1)) {
29830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29831 }
29832 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29833 {
29834 PyThreadState* __tstate = wxPyBeginAllowThreads();
29835 result = (PyObject *)(arg1)->GetSelf();
29836 wxPyEndAllowThreads(__tstate);
29837 if (PyErr_Occurred()) SWIG_fail;
29838 }
29839 resultobj = result;
29840 return resultobj;
29841 fail:
29842 return NULL;
29843 }
29844
29845
29846 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29847 PyObject *obj;
29848 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29849 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29850 return SWIG_Py_Void();
29851 }
29852
29853 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29854 return SWIG_Python_InitShadowInstance(args);
29855 }
29856
29857 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29858 PyObject *resultobj = 0;
29859 wxWindow *arg1 = (wxWindow *) 0 ;
29860 wxDateTime *arg2 = 0 ;
29861 wxEventType arg3 ;
29862 wxDateEvent *result = 0 ;
29863 void *argp1 = 0 ;
29864 int res1 = 0 ;
29865 void *argp2 = 0 ;
29866 int res2 = 0 ;
29867 int val3 ;
29868 int ecode3 = 0 ;
29869 PyObject * obj0 = 0 ;
29870 PyObject * obj1 = 0 ;
29871 PyObject * obj2 = 0 ;
29872 char * kwnames[] = {
29873 (char *) "win",(char *) "dt",(char *) "type", NULL
29874 };
29875
29876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29878 if (!SWIG_IsOK(res1)) {
29879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29880 }
29881 arg1 = reinterpret_cast< wxWindow * >(argp1);
29882 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29883 if (!SWIG_IsOK(res2)) {
29884 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29885 }
29886 if (!argp2) {
29887 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29888 }
29889 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29890 ecode3 = SWIG_AsVal_int(obj2, &val3);
29891 if (!SWIG_IsOK(ecode3)) {
29892 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29893 }
29894 arg3 = static_cast< wxEventType >(val3);
29895 {
29896 PyThreadState* __tstate = wxPyBeginAllowThreads();
29897 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29898 wxPyEndAllowThreads(__tstate);
29899 if (PyErr_Occurred()) SWIG_fail;
29900 }
29901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29902 return resultobj;
29903 fail:
29904 return NULL;
29905 }
29906
29907
29908 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29909 PyObject *resultobj = 0;
29910 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29911 wxDateTime *result = 0 ;
29912 void *argp1 = 0 ;
29913 int res1 = 0 ;
29914 PyObject *swig_obj[1] ;
29915
29916 if (!args) SWIG_fail;
29917 swig_obj[0] = args;
29918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29919 if (!SWIG_IsOK(res1)) {
29920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29921 }
29922 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29923 {
29924 PyThreadState* __tstate = wxPyBeginAllowThreads();
29925 {
29926 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29927 result = (wxDateTime *) &_result_ref;
29928 }
29929 wxPyEndAllowThreads(__tstate);
29930 if (PyErr_Occurred()) SWIG_fail;
29931 }
29932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29933 return resultobj;
29934 fail:
29935 return NULL;
29936 }
29937
29938
29939 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29940 PyObject *resultobj = 0;
29941 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29942 wxDateTime *arg2 = 0 ;
29943 void *argp1 = 0 ;
29944 int res1 = 0 ;
29945 void *argp2 = 0 ;
29946 int res2 = 0 ;
29947 PyObject * obj0 = 0 ;
29948 PyObject * obj1 = 0 ;
29949 char * kwnames[] = {
29950 (char *) "self",(char *) "date", NULL
29951 };
29952
29953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29955 if (!SWIG_IsOK(res1)) {
29956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29957 }
29958 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29959 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29960 if (!SWIG_IsOK(res2)) {
29961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29962 }
29963 if (!argp2) {
29964 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29965 }
29966 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29967 {
29968 PyThreadState* __tstate = wxPyBeginAllowThreads();
29969 (arg1)->SetDate((wxDateTime const &)*arg2);
29970 wxPyEndAllowThreads(__tstate);
29971 if (PyErr_Occurred()) SWIG_fail;
29972 }
29973 resultobj = SWIG_Py_Void();
29974 return resultobj;
29975 fail:
29976 return NULL;
29977 }
29978
29979
29980 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29981 PyObject *obj;
29982 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29983 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
29984 return SWIG_Py_Void();
29985 }
29986
29987 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29988 return SWIG_Python_InitShadowInstance(args);
29989 }
29990
29991 SWIGINTERN PyObject *_wrap_new_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29992 PyObject *resultobj = 0;
29993 wxWindow *arg1 = (wxWindow *) 0 ;
29994 wxEventType arg2 = (wxEventType) wxEVT_ANY ;
29995 wxEventBlocker *result = 0 ;
29996 void *argp1 = 0 ;
29997 int res1 = 0 ;
29998 int val2 ;
29999 int ecode2 = 0 ;
30000 PyObject * obj0 = 0 ;
30001 PyObject * obj1 = 0 ;
30002 char * kwnames[] = {
30003 (char *) "win",(char *) "type", NULL
30004 };
30005
30006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_EventBlocker",kwnames,&obj0,&obj1)) SWIG_fail;
30007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30008 if (!SWIG_IsOK(res1)) {
30009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventBlocker" "', expected argument " "1"" of type '" "wxWindow *""'");
30010 }
30011 arg1 = reinterpret_cast< wxWindow * >(argp1);
30012 if (obj1) {
30013 ecode2 = SWIG_AsVal_int(obj1, &val2);
30014 if (!SWIG_IsOK(ecode2)) {
30015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EventBlocker" "', expected argument " "2"" of type '" "wxEventType""'");
30016 }
30017 arg2 = static_cast< wxEventType >(val2);
30018 }
30019 {
30020 PyThreadState* __tstate = wxPyBeginAllowThreads();
30021 result = (wxEventBlocker *)new wxEventBlocker(arg1,arg2);
30022 wxPyEndAllowThreads(__tstate);
30023 if (PyErr_Occurred()) SWIG_fail;
30024 }
30025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_NEW | 0 );
30026 return resultobj;
30027 fail:
30028 return NULL;
30029 }
30030
30031
30032 SWIGINTERN PyObject *_wrap_delete_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30033 PyObject *resultobj = 0;
30034 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30035 void *argp1 = 0 ;
30036 int res1 = 0 ;
30037 PyObject *swig_obj[1] ;
30038
30039 if (!args) SWIG_fail;
30040 swig_obj[0] = args;
30041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_DISOWN | 0 );
30042 if (!SWIG_IsOK(res1)) {
30043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventBlocker" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30044 }
30045 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30046 {
30047 PyThreadState* __tstate = wxPyBeginAllowThreads();
30048 delete arg1;
30049
30050 wxPyEndAllowThreads(__tstate);
30051 if (PyErr_Occurred()) SWIG_fail;
30052 }
30053 resultobj = SWIG_Py_Void();
30054 return resultobj;
30055 fail:
30056 return NULL;
30057 }
30058
30059
30060 SWIGINTERN PyObject *_wrap_EventBlocker_Block(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30061 PyObject *resultobj = 0;
30062 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30063 wxEventType arg2 ;
30064 void *argp1 = 0 ;
30065 int res1 = 0 ;
30066 int val2 ;
30067 int ecode2 = 0 ;
30068 PyObject * obj0 = 0 ;
30069 PyObject * obj1 = 0 ;
30070 char * kwnames[] = {
30071 (char *) "self",(char *) "type", NULL
30072 };
30073
30074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EventBlocker_Block",kwnames,&obj0,&obj1)) SWIG_fail;
30075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventBlocker, 0 | 0 );
30076 if (!SWIG_IsOK(res1)) {
30077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventBlocker_Block" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30078 }
30079 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30080 ecode2 = SWIG_AsVal_int(obj1, &val2);
30081 if (!SWIG_IsOK(ecode2)) {
30082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventBlocker_Block" "', expected argument " "2"" of type '" "wxEventType""'");
30083 }
30084 arg2 = static_cast< wxEventType >(val2);
30085 {
30086 PyThreadState* __tstate = wxPyBeginAllowThreads();
30087 (arg1)->Block(arg2);
30088 wxPyEndAllowThreads(__tstate);
30089 if (PyErr_Occurred()) SWIG_fail;
30090 }
30091 resultobj = SWIG_Py_Void();
30092 return resultobj;
30093 fail:
30094 return NULL;
30095 }
30096
30097
30098 SWIGINTERN PyObject *EventBlocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30099 PyObject *obj;
30100 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30101 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventBlocker, SWIG_NewClientData(obj));
30102 return SWIG_Py_Void();
30103 }
30104
30105 SWIGINTERN PyObject *EventBlocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30106 return SWIG_Python_InitShadowInstance(args);
30107 }
30108
30109 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30110 PyObject *resultobj = 0;
30111 wxPyApp *result = 0 ;
30112
30113 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
30114 {
30115 PyThreadState* __tstate = wxPyBeginAllowThreads();
30116 result = (wxPyApp *)new_wxPyApp();
30117 wxPyEndAllowThreads(__tstate);
30118 if (PyErr_Occurred()) SWIG_fail;
30119 }
30120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
30121 return resultobj;
30122 fail:
30123 return NULL;
30124 }
30125
30126
30127 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30128 PyObject *resultobj = 0;
30129 wxPyApp *arg1 = (wxPyApp *) 0 ;
30130 void *argp1 = 0 ;
30131 int res1 = 0 ;
30132 PyObject *swig_obj[1] ;
30133
30134 if (!args) SWIG_fail;
30135 swig_obj[0] = args;
30136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
30137 if (!SWIG_IsOK(res1)) {
30138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
30139 }
30140 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30141 {
30142 PyThreadState* __tstate = wxPyBeginAllowThreads();
30143 delete arg1;
30144
30145 wxPyEndAllowThreads(__tstate);
30146 if (PyErr_Occurred()) SWIG_fail;
30147 }
30148 resultobj = SWIG_Py_Void();
30149 return resultobj;
30150 fail:
30151 return NULL;
30152 }
30153
30154
30155 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30156 PyObject *resultobj = 0;
30157 wxPyApp *arg1 = (wxPyApp *) 0 ;
30158 PyObject *arg2 = (PyObject *) 0 ;
30159 PyObject *arg3 = (PyObject *) 0 ;
30160 bool arg4 = (bool) false ;
30161 void *argp1 = 0 ;
30162 int res1 = 0 ;
30163 bool val4 ;
30164 int ecode4 = 0 ;
30165 PyObject * obj0 = 0 ;
30166 PyObject * obj1 = 0 ;
30167 PyObject * obj2 = 0 ;
30168 PyObject * obj3 = 0 ;
30169 char * kwnames[] = {
30170 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
30171 };
30172
30173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30175 if (!SWIG_IsOK(res1)) {
30176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
30177 }
30178 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30179 arg2 = obj1;
30180 arg3 = obj2;
30181 if (obj3) {
30182 ecode4 = SWIG_AsVal_bool(obj3, &val4);
30183 if (!SWIG_IsOK(ecode4)) {
30184 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
30185 }
30186 arg4 = static_cast< bool >(val4);
30187 }
30188 {
30189 PyThreadState* __tstate = wxPyBeginAllowThreads();
30190 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
30191 wxPyEndAllowThreads(__tstate);
30192 if (PyErr_Occurred()) SWIG_fail;
30193 }
30194 resultobj = SWIG_Py_Void();
30195 return resultobj;
30196 fail:
30197 return NULL;
30198 }
30199
30200
30201 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30202 PyObject *resultobj = 0;
30203 wxPyApp *arg1 = (wxPyApp *) 0 ;
30204 wxString result;
30205 void *argp1 = 0 ;
30206 int res1 = 0 ;
30207 PyObject *swig_obj[1] ;
30208
30209 if (!args) SWIG_fail;
30210 swig_obj[0] = args;
30211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30212 if (!SWIG_IsOK(res1)) {
30213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30214 }
30215 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30216 {
30217 PyThreadState* __tstate = wxPyBeginAllowThreads();
30218 result = ((wxPyApp const *)arg1)->GetAppName();
30219 wxPyEndAllowThreads(__tstate);
30220 if (PyErr_Occurred()) SWIG_fail;
30221 }
30222 {
30223 #if wxUSE_UNICODE
30224 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30225 #else
30226 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30227 #endif
30228 }
30229 return resultobj;
30230 fail:
30231 return NULL;
30232 }
30233
30234
30235 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30236 PyObject *resultobj = 0;
30237 wxPyApp *arg1 = (wxPyApp *) 0 ;
30238 wxString *arg2 = 0 ;
30239 void *argp1 = 0 ;
30240 int res1 = 0 ;
30241 bool temp2 = false ;
30242 PyObject * obj0 = 0 ;
30243 PyObject * obj1 = 0 ;
30244 char * kwnames[] = {
30245 (char *) "self",(char *) "name", NULL
30246 };
30247
30248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30250 if (!SWIG_IsOK(res1)) {
30251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30252 }
30253 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30254 {
30255 arg2 = wxString_in_helper(obj1);
30256 if (arg2 == NULL) SWIG_fail;
30257 temp2 = true;
30258 }
30259 {
30260 PyThreadState* __tstate = wxPyBeginAllowThreads();
30261 (arg1)->SetAppName((wxString const &)*arg2);
30262 wxPyEndAllowThreads(__tstate);
30263 if (PyErr_Occurred()) SWIG_fail;
30264 }
30265 resultobj = SWIG_Py_Void();
30266 {
30267 if (temp2)
30268 delete arg2;
30269 }
30270 return resultobj;
30271 fail:
30272 {
30273 if (temp2)
30274 delete arg2;
30275 }
30276 return NULL;
30277 }
30278
30279
30280 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30281 PyObject *resultobj = 0;
30282 wxPyApp *arg1 = (wxPyApp *) 0 ;
30283 wxString result;
30284 void *argp1 = 0 ;
30285 int res1 = 0 ;
30286 PyObject *swig_obj[1] ;
30287
30288 if (!args) SWIG_fail;
30289 swig_obj[0] = args;
30290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30291 if (!SWIG_IsOK(res1)) {
30292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30293 }
30294 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30295 {
30296 PyThreadState* __tstate = wxPyBeginAllowThreads();
30297 result = ((wxPyApp const *)arg1)->GetClassName();
30298 wxPyEndAllowThreads(__tstate);
30299 if (PyErr_Occurred()) SWIG_fail;
30300 }
30301 {
30302 #if wxUSE_UNICODE
30303 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30304 #else
30305 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30306 #endif
30307 }
30308 return resultobj;
30309 fail:
30310 return NULL;
30311 }
30312
30313
30314 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30315 PyObject *resultobj = 0;
30316 wxPyApp *arg1 = (wxPyApp *) 0 ;
30317 wxString *arg2 = 0 ;
30318 void *argp1 = 0 ;
30319 int res1 = 0 ;
30320 bool temp2 = false ;
30321 PyObject * obj0 = 0 ;
30322 PyObject * obj1 = 0 ;
30323 char * kwnames[] = {
30324 (char *) "self",(char *) "name", NULL
30325 };
30326
30327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30329 if (!SWIG_IsOK(res1)) {
30330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30331 }
30332 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30333 {
30334 arg2 = wxString_in_helper(obj1);
30335 if (arg2 == NULL) SWIG_fail;
30336 temp2 = true;
30337 }
30338 {
30339 PyThreadState* __tstate = wxPyBeginAllowThreads();
30340 (arg1)->SetClassName((wxString const &)*arg2);
30341 wxPyEndAllowThreads(__tstate);
30342 if (PyErr_Occurred()) SWIG_fail;
30343 }
30344 resultobj = SWIG_Py_Void();
30345 {
30346 if (temp2)
30347 delete arg2;
30348 }
30349 return resultobj;
30350 fail:
30351 {
30352 if (temp2)
30353 delete arg2;
30354 }
30355 return NULL;
30356 }
30357
30358
30359 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30360 PyObject *resultobj = 0;
30361 wxPyApp *arg1 = (wxPyApp *) 0 ;
30362 wxString *result = 0 ;
30363 void *argp1 = 0 ;
30364 int res1 = 0 ;
30365 PyObject *swig_obj[1] ;
30366
30367 if (!args) SWIG_fail;
30368 swig_obj[0] = args;
30369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30370 if (!SWIG_IsOK(res1)) {
30371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30372 }
30373 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30374 {
30375 PyThreadState* __tstate = wxPyBeginAllowThreads();
30376 {
30377 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30378 result = (wxString *) &_result_ref;
30379 }
30380 wxPyEndAllowThreads(__tstate);
30381 if (PyErr_Occurred()) SWIG_fail;
30382 }
30383 {
30384 #if wxUSE_UNICODE
30385 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30386 #else
30387 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30388 #endif
30389 }
30390 return resultobj;
30391 fail:
30392 return NULL;
30393 }
30394
30395
30396 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30397 PyObject *resultobj = 0;
30398 wxPyApp *arg1 = (wxPyApp *) 0 ;
30399 wxString *arg2 = 0 ;
30400 void *argp1 = 0 ;
30401 int res1 = 0 ;
30402 bool temp2 = false ;
30403 PyObject * obj0 = 0 ;
30404 PyObject * obj1 = 0 ;
30405 char * kwnames[] = {
30406 (char *) "self",(char *) "name", NULL
30407 };
30408
30409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30411 if (!SWIG_IsOK(res1)) {
30412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30413 }
30414 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30415 {
30416 arg2 = wxString_in_helper(obj1);
30417 if (arg2 == NULL) SWIG_fail;
30418 temp2 = true;
30419 }
30420 {
30421 PyThreadState* __tstate = wxPyBeginAllowThreads();
30422 (arg1)->SetVendorName((wxString const &)*arg2);
30423 wxPyEndAllowThreads(__tstate);
30424 if (PyErr_Occurred()) SWIG_fail;
30425 }
30426 resultobj = SWIG_Py_Void();
30427 {
30428 if (temp2)
30429 delete arg2;
30430 }
30431 return resultobj;
30432 fail:
30433 {
30434 if (temp2)
30435 delete arg2;
30436 }
30437 return NULL;
30438 }
30439
30440
30441 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30442 PyObject *resultobj = 0;
30443 wxPyApp *arg1 = (wxPyApp *) 0 ;
30444 wxAppTraits *result = 0 ;
30445 void *argp1 = 0 ;
30446 int res1 = 0 ;
30447 PyObject *swig_obj[1] ;
30448
30449 if (!args) SWIG_fail;
30450 swig_obj[0] = args;
30451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30452 if (!SWIG_IsOK(res1)) {
30453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30454 }
30455 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30456 {
30457 PyThreadState* __tstate = wxPyBeginAllowThreads();
30458 result = (wxAppTraits *)(arg1)->GetTraits();
30459 wxPyEndAllowThreads(__tstate);
30460 if (PyErr_Occurred()) SWIG_fail;
30461 }
30462 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30463 return resultobj;
30464 fail:
30465 return NULL;
30466 }
30467
30468
30469 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30470 PyObject *resultobj = 0;
30471 wxPyApp *arg1 = (wxPyApp *) 0 ;
30472 void *argp1 = 0 ;
30473 int res1 = 0 ;
30474 PyObject *swig_obj[1] ;
30475
30476 if (!args) SWIG_fail;
30477 swig_obj[0] = args;
30478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30479 if (!SWIG_IsOK(res1)) {
30480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30481 }
30482 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30483 {
30484 PyThreadState* __tstate = wxPyBeginAllowThreads();
30485 (arg1)->ProcessPendingEvents();
30486 wxPyEndAllowThreads(__tstate);
30487 if (PyErr_Occurred()) SWIG_fail;
30488 }
30489 resultobj = SWIG_Py_Void();
30490 return resultobj;
30491 fail:
30492 return NULL;
30493 }
30494
30495
30496 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30497 PyObject *resultobj = 0;
30498 wxPyApp *arg1 = (wxPyApp *) 0 ;
30499 bool arg2 = (bool) false ;
30500 bool result;
30501 void *argp1 = 0 ;
30502 int res1 = 0 ;
30503 bool val2 ;
30504 int ecode2 = 0 ;
30505 PyObject * obj0 = 0 ;
30506 PyObject * obj1 = 0 ;
30507 char * kwnames[] = {
30508 (char *) "self",(char *) "onlyIfNeeded", NULL
30509 };
30510
30511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30513 if (!SWIG_IsOK(res1)) {
30514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30515 }
30516 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30517 if (obj1) {
30518 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30519 if (!SWIG_IsOK(ecode2)) {
30520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30521 }
30522 arg2 = static_cast< bool >(val2);
30523 }
30524 {
30525 PyThreadState* __tstate = wxPyBeginAllowThreads();
30526 result = (bool)(arg1)->Yield(arg2);
30527 wxPyEndAllowThreads(__tstate);
30528 if (PyErr_Occurred()) SWIG_fail;
30529 }
30530 {
30531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30532 }
30533 return resultobj;
30534 fail:
30535 return NULL;
30536 }
30537
30538
30539 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30540 PyObject *resultobj = 0;
30541 wxPyApp *arg1 = (wxPyApp *) 0 ;
30542 void *argp1 = 0 ;
30543 int res1 = 0 ;
30544 PyObject *swig_obj[1] ;
30545
30546 if (!args) SWIG_fail;
30547 swig_obj[0] = args;
30548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30549 if (!SWIG_IsOK(res1)) {
30550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30551 }
30552 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30553 {
30554 PyThreadState* __tstate = wxPyBeginAllowThreads();
30555 (arg1)->WakeUpIdle();
30556 wxPyEndAllowThreads(__tstate);
30557 if (PyErr_Occurred()) SWIG_fail;
30558 }
30559 resultobj = SWIG_Py_Void();
30560 return resultobj;
30561 fail:
30562 return NULL;
30563 }
30564
30565
30566 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30567 PyObject *resultobj = 0;
30568 bool result;
30569
30570 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30571 {
30572 PyThreadState* __tstate = wxPyBeginAllowThreads();
30573 result = (bool)wxPyApp::IsMainLoopRunning();
30574 wxPyEndAllowThreads(__tstate);
30575 if (PyErr_Occurred()) SWIG_fail;
30576 }
30577 {
30578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30579 }
30580 return resultobj;
30581 fail:
30582 return NULL;
30583 }
30584
30585
30586 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30587 PyObject *resultobj = 0;
30588 wxPyApp *arg1 = (wxPyApp *) 0 ;
30589 int result;
30590 void *argp1 = 0 ;
30591 int res1 = 0 ;
30592 PyObject *swig_obj[1] ;
30593
30594 if (!args) SWIG_fail;
30595 swig_obj[0] = args;
30596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30597 if (!SWIG_IsOK(res1)) {
30598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30599 }
30600 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30601 {
30602 PyThreadState* __tstate = wxPyBeginAllowThreads();
30603 result = (int)(arg1)->MainLoop();
30604 wxPyEndAllowThreads(__tstate);
30605 if (PyErr_Occurred()) SWIG_fail;
30606 }
30607 resultobj = SWIG_From_int(static_cast< int >(result));
30608 return resultobj;
30609 fail:
30610 return NULL;
30611 }
30612
30613
30614 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30615 PyObject *resultobj = 0;
30616 wxPyApp *arg1 = (wxPyApp *) 0 ;
30617 void *argp1 = 0 ;
30618 int res1 = 0 ;
30619 PyObject *swig_obj[1] ;
30620
30621 if (!args) SWIG_fail;
30622 swig_obj[0] = args;
30623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30624 if (!SWIG_IsOK(res1)) {
30625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30626 }
30627 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30628 {
30629 PyThreadState* __tstate = wxPyBeginAllowThreads();
30630 (arg1)->Exit();
30631 wxPyEndAllowThreads(__tstate);
30632 if (PyErr_Occurred()) SWIG_fail;
30633 }
30634 resultobj = SWIG_Py_Void();
30635 return resultobj;
30636 fail:
30637 return NULL;
30638 }
30639
30640
30641 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30642 PyObject *resultobj = 0;
30643 wxPyApp *arg1 = (wxPyApp *) 0 ;
30644 wxLayoutDirection result;
30645 void *argp1 = 0 ;
30646 int res1 = 0 ;
30647 PyObject *swig_obj[1] ;
30648
30649 if (!args) SWIG_fail;
30650 swig_obj[0] = args;
30651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30652 if (!SWIG_IsOK(res1)) {
30653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30654 }
30655 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30656 {
30657 PyThreadState* __tstate = wxPyBeginAllowThreads();
30658 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30659 wxPyEndAllowThreads(__tstate);
30660 if (PyErr_Occurred()) SWIG_fail;
30661 }
30662 resultobj = SWIG_From_int(static_cast< int >(result));
30663 return resultobj;
30664 fail:
30665 return NULL;
30666 }
30667
30668
30669 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30670 PyObject *resultobj = 0;
30671 wxPyApp *arg1 = (wxPyApp *) 0 ;
30672 void *argp1 = 0 ;
30673 int res1 = 0 ;
30674 PyObject *swig_obj[1] ;
30675
30676 if (!args) SWIG_fail;
30677 swig_obj[0] = args;
30678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30679 if (!SWIG_IsOK(res1)) {
30680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30681 }
30682 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30683 {
30684 PyThreadState* __tstate = wxPyBeginAllowThreads();
30685 (arg1)->ExitMainLoop();
30686 wxPyEndAllowThreads(__tstate);
30687 if (PyErr_Occurred()) SWIG_fail;
30688 }
30689 resultobj = SWIG_Py_Void();
30690 return resultobj;
30691 fail:
30692 return NULL;
30693 }
30694
30695
30696 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30697 PyObject *resultobj = 0;
30698 wxPyApp *arg1 = (wxPyApp *) 0 ;
30699 bool result;
30700 void *argp1 = 0 ;
30701 int res1 = 0 ;
30702 PyObject *swig_obj[1] ;
30703
30704 if (!args) SWIG_fail;
30705 swig_obj[0] = args;
30706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30707 if (!SWIG_IsOK(res1)) {
30708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30709 }
30710 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30711 {
30712 PyThreadState* __tstate = wxPyBeginAllowThreads();
30713 result = (bool)(arg1)->Pending();
30714 wxPyEndAllowThreads(__tstate);
30715 if (PyErr_Occurred()) SWIG_fail;
30716 }
30717 {
30718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30719 }
30720 return resultobj;
30721 fail:
30722 return NULL;
30723 }
30724
30725
30726 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30727 PyObject *resultobj = 0;
30728 wxPyApp *arg1 = (wxPyApp *) 0 ;
30729 bool result;
30730 void *argp1 = 0 ;
30731 int res1 = 0 ;
30732 PyObject *swig_obj[1] ;
30733
30734 if (!args) SWIG_fail;
30735 swig_obj[0] = args;
30736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30737 if (!SWIG_IsOK(res1)) {
30738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30739 }
30740 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30741 {
30742 PyThreadState* __tstate = wxPyBeginAllowThreads();
30743 result = (bool)(arg1)->Dispatch();
30744 wxPyEndAllowThreads(__tstate);
30745 if (PyErr_Occurred()) SWIG_fail;
30746 }
30747 {
30748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30749 }
30750 return resultobj;
30751 fail:
30752 return NULL;
30753 }
30754
30755
30756 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30757 PyObject *resultobj = 0;
30758 wxPyApp *arg1 = (wxPyApp *) 0 ;
30759 bool result;
30760 void *argp1 = 0 ;
30761 int res1 = 0 ;
30762 PyObject *swig_obj[1] ;
30763
30764 if (!args) SWIG_fail;
30765 swig_obj[0] = args;
30766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30767 if (!SWIG_IsOK(res1)) {
30768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30769 }
30770 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30771 {
30772 PyThreadState* __tstate = wxPyBeginAllowThreads();
30773 result = (bool)(arg1)->ProcessIdle();
30774 wxPyEndAllowThreads(__tstate);
30775 if (PyErr_Occurred()) SWIG_fail;
30776 }
30777 {
30778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30779 }
30780 return resultobj;
30781 fail:
30782 return NULL;
30783 }
30784
30785
30786 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30787 PyObject *resultobj = 0;
30788 wxPyApp *arg1 = (wxPyApp *) 0 ;
30789 wxWindow *arg2 = (wxWindow *) 0 ;
30790 wxIdleEvent *arg3 = 0 ;
30791 bool result;
30792 void *argp1 = 0 ;
30793 int res1 = 0 ;
30794 void *argp2 = 0 ;
30795 int res2 = 0 ;
30796 void *argp3 = 0 ;
30797 int res3 = 0 ;
30798 PyObject * obj0 = 0 ;
30799 PyObject * obj1 = 0 ;
30800 PyObject * obj2 = 0 ;
30801 char * kwnames[] = {
30802 (char *) "self",(char *) "win",(char *) "event", NULL
30803 };
30804
30805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30807 if (!SWIG_IsOK(res1)) {
30808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30809 }
30810 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30811 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30812 if (!SWIG_IsOK(res2)) {
30813 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30814 }
30815 arg2 = reinterpret_cast< wxWindow * >(argp2);
30816 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30817 if (!SWIG_IsOK(res3)) {
30818 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30819 }
30820 if (!argp3) {
30821 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30822 }
30823 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30824 {
30825 PyThreadState* __tstate = wxPyBeginAllowThreads();
30826 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30827 wxPyEndAllowThreads(__tstate);
30828 if (PyErr_Occurred()) SWIG_fail;
30829 }
30830 {
30831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30832 }
30833 return resultobj;
30834 fail:
30835 return NULL;
30836 }
30837
30838
30839 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30840 PyObject *resultobj = 0;
30841 wxPyApp *arg1 = (wxPyApp *) 0 ;
30842 bool result;
30843 void *argp1 = 0 ;
30844 int res1 = 0 ;
30845 PyObject *swig_obj[1] ;
30846
30847 if (!args) SWIG_fail;
30848 swig_obj[0] = args;
30849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30850 if (!SWIG_IsOK(res1)) {
30851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30852 }
30853 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30854 {
30855 PyThreadState* __tstate = wxPyBeginAllowThreads();
30856 result = (bool)((wxPyApp const *)arg1)->IsActive();
30857 wxPyEndAllowThreads(__tstate);
30858 if (PyErr_Occurred()) SWIG_fail;
30859 }
30860 {
30861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30862 }
30863 return resultobj;
30864 fail:
30865 return NULL;
30866 }
30867
30868
30869 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30870 PyObject *resultobj = 0;
30871 wxPyApp *arg1 = (wxPyApp *) 0 ;
30872 wxWindow *arg2 = (wxWindow *) 0 ;
30873 void *argp1 = 0 ;
30874 int res1 = 0 ;
30875 void *argp2 = 0 ;
30876 int res2 = 0 ;
30877 PyObject * obj0 = 0 ;
30878 PyObject * obj1 = 0 ;
30879 char * kwnames[] = {
30880 (char *) "self",(char *) "win", NULL
30881 };
30882
30883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30885 if (!SWIG_IsOK(res1)) {
30886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30887 }
30888 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30889 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30890 if (!SWIG_IsOK(res2)) {
30891 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30892 }
30893 arg2 = reinterpret_cast< wxWindow * >(argp2);
30894 {
30895 PyThreadState* __tstate = wxPyBeginAllowThreads();
30896 (arg1)->SetTopWindow(arg2);
30897 wxPyEndAllowThreads(__tstate);
30898 if (PyErr_Occurred()) SWIG_fail;
30899 }
30900 resultobj = SWIG_Py_Void();
30901 return resultobj;
30902 fail:
30903 return NULL;
30904 }
30905
30906
30907 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30908 PyObject *resultobj = 0;
30909 wxPyApp *arg1 = (wxPyApp *) 0 ;
30910 wxWindow *result = 0 ;
30911 void *argp1 = 0 ;
30912 int res1 = 0 ;
30913 PyObject *swig_obj[1] ;
30914
30915 if (!args) SWIG_fail;
30916 swig_obj[0] = args;
30917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30918 if (!SWIG_IsOK(res1)) {
30919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30920 }
30921 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30922 {
30923 PyThreadState* __tstate = wxPyBeginAllowThreads();
30924 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30925 wxPyEndAllowThreads(__tstate);
30926 if (PyErr_Occurred()) SWIG_fail;
30927 }
30928 {
30929 resultobj = wxPyMake_wxObject(result, (bool)0);
30930 }
30931 return resultobj;
30932 fail:
30933 return NULL;
30934 }
30935
30936
30937 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30938 PyObject *resultobj = 0;
30939 wxPyApp *arg1 = (wxPyApp *) 0 ;
30940 bool arg2 ;
30941 void *argp1 = 0 ;
30942 int res1 = 0 ;
30943 bool val2 ;
30944 int ecode2 = 0 ;
30945 PyObject * obj0 = 0 ;
30946 PyObject * obj1 = 0 ;
30947 char * kwnames[] = {
30948 (char *) "self",(char *) "flag", NULL
30949 };
30950
30951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30953 if (!SWIG_IsOK(res1)) {
30954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30955 }
30956 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30957 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30958 if (!SWIG_IsOK(ecode2)) {
30959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30960 }
30961 arg2 = static_cast< bool >(val2);
30962 {
30963 PyThreadState* __tstate = wxPyBeginAllowThreads();
30964 (arg1)->SetExitOnFrameDelete(arg2);
30965 wxPyEndAllowThreads(__tstate);
30966 if (PyErr_Occurred()) SWIG_fail;
30967 }
30968 resultobj = SWIG_Py_Void();
30969 return resultobj;
30970 fail:
30971 return NULL;
30972 }
30973
30974
30975 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30976 PyObject *resultobj = 0;
30977 wxPyApp *arg1 = (wxPyApp *) 0 ;
30978 bool result;
30979 void *argp1 = 0 ;
30980 int res1 = 0 ;
30981 PyObject *swig_obj[1] ;
30982
30983 if (!args) SWIG_fail;
30984 swig_obj[0] = args;
30985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30986 if (!SWIG_IsOK(res1)) {
30987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30988 }
30989 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30990 {
30991 PyThreadState* __tstate = wxPyBeginAllowThreads();
30992 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30993 wxPyEndAllowThreads(__tstate);
30994 if (PyErr_Occurred()) SWIG_fail;
30995 }
30996 {
30997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30998 }
30999 return resultobj;
31000 fail:
31001 return NULL;
31002 }
31003
31004
31005 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31006 PyObject *resultobj = 0;
31007 wxPyApp *arg1 = (wxPyApp *) 0 ;
31008 bool arg2 ;
31009 bool arg3 = (bool) false ;
31010 void *argp1 = 0 ;
31011 int res1 = 0 ;
31012 bool val2 ;
31013 int ecode2 = 0 ;
31014 bool val3 ;
31015 int ecode3 = 0 ;
31016 PyObject * obj0 = 0 ;
31017 PyObject * obj1 = 0 ;
31018 PyObject * obj2 = 0 ;
31019 char * kwnames[] = {
31020 (char *) "self",(char *) "flag",(char *) "forceTrueColour", NULL
31021 };
31022
31023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31025 if (!SWIG_IsOK(res1)) {
31026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
31027 }
31028 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31029 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31030 if (!SWIG_IsOK(ecode2)) {
31031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
31032 }
31033 arg2 = static_cast< bool >(val2);
31034 if (obj2) {
31035 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31036 if (!SWIG_IsOK(ecode3)) {
31037 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "3"" of type '" "bool""'");
31038 }
31039 arg3 = static_cast< bool >(val3);
31040 }
31041 {
31042 PyThreadState* __tstate = wxPyBeginAllowThreads();
31043 (arg1)->SetUseBestVisual(arg2,arg3);
31044 wxPyEndAllowThreads(__tstate);
31045 if (PyErr_Occurred()) SWIG_fail;
31046 }
31047 resultobj = SWIG_Py_Void();
31048 return resultobj;
31049 fail:
31050 return NULL;
31051 }
31052
31053
31054 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31055 PyObject *resultobj = 0;
31056 wxPyApp *arg1 = (wxPyApp *) 0 ;
31057 bool result;
31058 void *argp1 = 0 ;
31059 int res1 = 0 ;
31060 PyObject *swig_obj[1] ;
31061
31062 if (!args) SWIG_fail;
31063 swig_obj[0] = args;
31064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31065 if (!SWIG_IsOK(res1)) {
31066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31067 }
31068 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31069 {
31070 PyThreadState* __tstate = wxPyBeginAllowThreads();
31071 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
31072 wxPyEndAllowThreads(__tstate);
31073 if (PyErr_Occurred()) SWIG_fail;
31074 }
31075 {
31076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31077 }
31078 return resultobj;
31079 fail:
31080 return NULL;
31081 }
31082
31083
31084 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31085 PyObject *resultobj = 0;
31086 wxPyApp *arg1 = (wxPyApp *) 0 ;
31087 int arg2 ;
31088 void *argp1 = 0 ;
31089 int res1 = 0 ;
31090 int val2 ;
31091 int ecode2 = 0 ;
31092 PyObject * obj0 = 0 ;
31093 PyObject * obj1 = 0 ;
31094 char * kwnames[] = {
31095 (char *) "self",(char *) "mode", NULL
31096 };
31097
31098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
31099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31100 if (!SWIG_IsOK(res1)) {
31101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31102 }
31103 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31104 ecode2 = SWIG_AsVal_int(obj1, &val2);
31105 if (!SWIG_IsOK(ecode2)) {
31106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
31107 }
31108 arg2 = static_cast< int >(val2);
31109 {
31110 PyThreadState* __tstate = wxPyBeginAllowThreads();
31111 (arg1)->SetPrintMode(arg2);
31112 wxPyEndAllowThreads(__tstate);
31113 if (PyErr_Occurred()) SWIG_fail;
31114 }
31115 resultobj = SWIG_Py_Void();
31116 return resultobj;
31117 fail:
31118 return NULL;
31119 }
31120
31121
31122 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31123 PyObject *resultobj = 0;
31124 wxPyApp *arg1 = (wxPyApp *) 0 ;
31125 int result;
31126 void *argp1 = 0 ;
31127 int res1 = 0 ;
31128 PyObject *swig_obj[1] ;
31129
31130 if (!args) SWIG_fail;
31131 swig_obj[0] = args;
31132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31133 if (!SWIG_IsOK(res1)) {
31134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31135 }
31136 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31137 {
31138 PyThreadState* __tstate = wxPyBeginAllowThreads();
31139 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
31140 wxPyEndAllowThreads(__tstate);
31141 if (PyErr_Occurred()) SWIG_fail;
31142 }
31143 resultobj = SWIG_From_int(static_cast< int >(result));
31144 return resultobj;
31145 fail:
31146 return NULL;
31147 }
31148
31149
31150 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31151 PyObject *resultobj = 0;
31152 wxPyApp *arg1 = (wxPyApp *) 0 ;
31153 int arg2 ;
31154 void *argp1 = 0 ;
31155 int res1 = 0 ;
31156 int val2 ;
31157 int ecode2 = 0 ;
31158 PyObject * obj0 = 0 ;
31159 PyObject * obj1 = 0 ;
31160 char * kwnames[] = {
31161 (char *) "self",(char *) "mode", NULL
31162 };
31163
31164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
31165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31166 if (!SWIG_IsOK(res1)) {
31167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31168 }
31169 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31170 ecode2 = SWIG_AsVal_int(obj1, &val2);
31171 if (!SWIG_IsOK(ecode2)) {
31172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
31173 }
31174 arg2 = static_cast< int >(val2);
31175 {
31176 PyThreadState* __tstate = wxPyBeginAllowThreads();
31177 (arg1)->SetAssertMode(arg2);
31178 wxPyEndAllowThreads(__tstate);
31179 if (PyErr_Occurred()) SWIG_fail;
31180 }
31181 resultobj = SWIG_Py_Void();
31182 return resultobj;
31183 fail:
31184 return NULL;
31185 }
31186
31187
31188 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31189 PyObject *resultobj = 0;
31190 wxPyApp *arg1 = (wxPyApp *) 0 ;
31191 int result;
31192 void *argp1 = 0 ;
31193 int res1 = 0 ;
31194 PyObject *swig_obj[1] ;
31195
31196 if (!args) SWIG_fail;
31197 swig_obj[0] = args;
31198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31199 if (!SWIG_IsOK(res1)) {
31200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31201 }
31202 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31203 {
31204 PyThreadState* __tstate = wxPyBeginAllowThreads();
31205 result = (int)(arg1)->GetAssertMode();
31206 wxPyEndAllowThreads(__tstate);
31207 if (PyErr_Occurred()) SWIG_fail;
31208 }
31209 resultobj = SWIG_From_int(static_cast< int >(result));
31210 return resultobj;
31211 fail:
31212 return NULL;
31213 }
31214
31215
31216 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31217 PyObject *resultobj = 0;
31218 bool result;
31219
31220 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31221 {
31222 PyThreadState* __tstate = wxPyBeginAllowThreads();
31223 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31224 wxPyEndAllowThreads(__tstate);
31225 if (PyErr_Occurred()) SWIG_fail;
31226 }
31227 {
31228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31229 }
31230 return resultobj;
31231 fail:
31232 return NULL;
31233 }
31234
31235
31236 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31237 PyObject *resultobj = 0;
31238 long result;
31239
31240 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31241 {
31242 PyThreadState* __tstate = wxPyBeginAllowThreads();
31243 result = (long)wxPyApp::GetMacAboutMenuItemId();
31244 wxPyEndAllowThreads(__tstate);
31245 if (PyErr_Occurred()) SWIG_fail;
31246 }
31247 resultobj = SWIG_From_long(static_cast< long >(result));
31248 return resultobj;
31249 fail:
31250 return NULL;
31251 }
31252
31253
31254 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31255 PyObject *resultobj = 0;
31256 long result;
31257
31258 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31259 {
31260 PyThreadState* __tstate = wxPyBeginAllowThreads();
31261 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31262 wxPyEndAllowThreads(__tstate);
31263 if (PyErr_Occurred()) SWIG_fail;
31264 }
31265 resultobj = SWIG_From_long(static_cast< long >(result));
31266 return resultobj;
31267 fail:
31268 return NULL;
31269 }
31270
31271
31272 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31273 PyObject *resultobj = 0;
31274 long result;
31275
31276 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31277 {
31278 PyThreadState* __tstate = wxPyBeginAllowThreads();
31279 result = (long)wxPyApp::GetMacExitMenuItemId();
31280 wxPyEndAllowThreads(__tstate);
31281 if (PyErr_Occurred()) SWIG_fail;
31282 }
31283 resultobj = SWIG_From_long(static_cast< long >(result));
31284 return resultobj;
31285 fail:
31286 return NULL;
31287 }
31288
31289
31290 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31291 PyObject *resultobj = 0;
31292 wxString result;
31293
31294 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31295 {
31296 PyThreadState* __tstate = wxPyBeginAllowThreads();
31297 result = wxPyApp::GetMacHelpMenuTitleName();
31298 wxPyEndAllowThreads(__tstate);
31299 if (PyErr_Occurred()) SWIG_fail;
31300 }
31301 {
31302 #if wxUSE_UNICODE
31303 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31304 #else
31305 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31306 #endif
31307 }
31308 return resultobj;
31309 fail:
31310 return NULL;
31311 }
31312
31313
31314 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31315 PyObject *resultobj = 0;
31316 bool arg1 ;
31317 bool val1 ;
31318 int ecode1 = 0 ;
31319 PyObject * obj0 = 0 ;
31320 char * kwnames[] = {
31321 (char *) "val", NULL
31322 };
31323
31324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31325 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31326 if (!SWIG_IsOK(ecode1)) {
31327 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31328 }
31329 arg1 = static_cast< bool >(val1);
31330 {
31331 PyThreadState* __tstate = wxPyBeginAllowThreads();
31332 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31333 wxPyEndAllowThreads(__tstate);
31334 if (PyErr_Occurred()) SWIG_fail;
31335 }
31336 resultobj = SWIG_Py_Void();
31337 return resultobj;
31338 fail:
31339 return NULL;
31340 }
31341
31342
31343 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31344 PyObject *resultobj = 0;
31345 long arg1 ;
31346 long val1 ;
31347 int ecode1 = 0 ;
31348 PyObject * obj0 = 0 ;
31349 char * kwnames[] = {
31350 (char *) "val", NULL
31351 };
31352
31353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31354 ecode1 = SWIG_AsVal_long(obj0, &val1);
31355 if (!SWIG_IsOK(ecode1)) {
31356 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31357 }
31358 arg1 = static_cast< long >(val1);
31359 {
31360 PyThreadState* __tstate = wxPyBeginAllowThreads();
31361 wxPyApp::SetMacAboutMenuItemId(arg1);
31362 wxPyEndAllowThreads(__tstate);
31363 if (PyErr_Occurred()) SWIG_fail;
31364 }
31365 resultobj = SWIG_Py_Void();
31366 return resultobj;
31367 fail:
31368 return NULL;
31369 }
31370
31371
31372 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31373 PyObject *resultobj = 0;
31374 long arg1 ;
31375 long val1 ;
31376 int ecode1 = 0 ;
31377 PyObject * obj0 = 0 ;
31378 char * kwnames[] = {
31379 (char *) "val", NULL
31380 };
31381
31382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31383 ecode1 = SWIG_AsVal_long(obj0, &val1);
31384 if (!SWIG_IsOK(ecode1)) {
31385 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31386 }
31387 arg1 = static_cast< long >(val1);
31388 {
31389 PyThreadState* __tstate = wxPyBeginAllowThreads();
31390 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31391 wxPyEndAllowThreads(__tstate);
31392 if (PyErr_Occurred()) SWIG_fail;
31393 }
31394 resultobj = SWIG_Py_Void();
31395 return resultobj;
31396 fail:
31397 return NULL;
31398 }
31399
31400
31401 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31402 PyObject *resultobj = 0;
31403 long arg1 ;
31404 long val1 ;
31405 int ecode1 = 0 ;
31406 PyObject * obj0 = 0 ;
31407 char * kwnames[] = {
31408 (char *) "val", NULL
31409 };
31410
31411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31412 ecode1 = SWIG_AsVal_long(obj0, &val1);
31413 if (!SWIG_IsOK(ecode1)) {
31414 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31415 }
31416 arg1 = static_cast< long >(val1);
31417 {
31418 PyThreadState* __tstate = wxPyBeginAllowThreads();
31419 wxPyApp::SetMacExitMenuItemId(arg1);
31420 wxPyEndAllowThreads(__tstate);
31421 if (PyErr_Occurred()) SWIG_fail;
31422 }
31423 resultobj = SWIG_Py_Void();
31424 return resultobj;
31425 fail:
31426 return NULL;
31427 }
31428
31429
31430 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31431 PyObject *resultobj = 0;
31432 wxString *arg1 = 0 ;
31433 bool temp1 = false ;
31434 PyObject * obj0 = 0 ;
31435 char * kwnames[] = {
31436 (char *) "val", NULL
31437 };
31438
31439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31440 {
31441 arg1 = wxString_in_helper(obj0);
31442 if (arg1 == NULL) SWIG_fail;
31443 temp1 = true;
31444 }
31445 {
31446 PyThreadState* __tstate = wxPyBeginAllowThreads();
31447 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31448 wxPyEndAllowThreads(__tstate);
31449 if (PyErr_Occurred()) SWIG_fail;
31450 }
31451 resultobj = SWIG_Py_Void();
31452 {
31453 if (temp1)
31454 delete arg1;
31455 }
31456 return resultobj;
31457 fail:
31458 {
31459 if (temp1)
31460 delete arg1;
31461 }
31462 return NULL;
31463 }
31464
31465
31466 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31467 PyObject *resultobj = 0;
31468 wxPyApp *arg1 = (wxPyApp *) 0 ;
31469 void *argp1 = 0 ;
31470 int res1 = 0 ;
31471 PyObject *swig_obj[1] ;
31472
31473 if (!args) SWIG_fail;
31474 swig_obj[0] = args;
31475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31476 if (!SWIG_IsOK(res1)) {
31477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31478 }
31479 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31480 {
31481 PyThreadState* __tstate = wxPyBeginAllowThreads();
31482 (arg1)->_BootstrapApp();
31483 wxPyEndAllowThreads(__tstate);
31484 if (PyErr_Occurred()) SWIG_fail;
31485 }
31486 resultobj = SWIG_Py_Void();
31487 return resultobj;
31488 fail:
31489 return NULL;
31490 }
31491
31492
31493 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31494 PyObject *resultobj = 0;
31495 int result;
31496
31497 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31498 {
31499 PyThreadState* __tstate = wxPyBeginAllowThreads();
31500 result = (int)wxPyApp::GetComCtl32Version();
31501 wxPyEndAllowThreads(__tstate);
31502 if (PyErr_Occurred()) SWIG_fail;
31503 }
31504 resultobj = SWIG_From_int(static_cast< int >(result));
31505 return resultobj;
31506 fail:
31507 return NULL;
31508 }
31509
31510
31511 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31512 PyObject *resultobj = 0;
31513 bool result;
31514
31515 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31516 {
31517 PyThreadState* __tstate = wxPyBeginAllowThreads();
31518 result = (bool)wxPyApp_IsDisplayAvailable();
31519 wxPyEndAllowThreads(__tstate);
31520 if (PyErr_Occurred()) SWIG_fail;
31521 }
31522 {
31523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31524 }
31525 return resultobj;
31526 fail:
31527 return NULL;
31528 }
31529
31530
31531 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31532 PyObject *obj;
31533 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31534 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31535 return SWIG_Py_Void();
31536 }
31537
31538 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31539 return SWIG_Python_InitShadowInstance(args);
31540 }
31541
31542 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31543 PyObject *resultobj = 0;
31544
31545 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31546 {
31547 PyThreadState* __tstate = wxPyBeginAllowThreads();
31548 wxExit();
31549 wxPyEndAllowThreads(__tstate);
31550 if (PyErr_Occurred()) SWIG_fail;
31551 }
31552 resultobj = SWIG_Py_Void();
31553 return resultobj;
31554 fail:
31555 return NULL;
31556 }
31557
31558
31559 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31560 PyObject *resultobj = 0;
31561 bool result;
31562
31563 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31564 {
31565 PyThreadState* __tstate = wxPyBeginAllowThreads();
31566 result = (bool)wxYield();
31567 wxPyEndAllowThreads(__tstate);
31568 if (PyErr_Occurred()) SWIG_fail;
31569 }
31570 {
31571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31572 }
31573 return resultobj;
31574 fail:
31575 return NULL;
31576 }
31577
31578
31579 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31580 PyObject *resultobj = 0;
31581 bool result;
31582
31583 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31584 {
31585 PyThreadState* __tstate = wxPyBeginAllowThreads();
31586 result = (bool)wxYieldIfNeeded();
31587 wxPyEndAllowThreads(__tstate);
31588 if (PyErr_Occurred()) SWIG_fail;
31589 }
31590 {
31591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31592 }
31593 return resultobj;
31594 fail:
31595 return NULL;
31596 }
31597
31598
31599 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31600 PyObject *resultobj = 0;
31601 wxWindow *arg1 = (wxWindow *) NULL ;
31602 bool arg2 = (bool) false ;
31603 bool result;
31604 void *argp1 = 0 ;
31605 int res1 = 0 ;
31606 bool val2 ;
31607 int ecode2 = 0 ;
31608 PyObject * obj0 = 0 ;
31609 PyObject * obj1 = 0 ;
31610 char * kwnames[] = {
31611 (char *) "win",(char *) "onlyIfNeeded", NULL
31612 };
31613
31614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31615 if (obj0) {
31616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31617 if (!SWIG_IsOK(res1)) {
31618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31619 }
31620 arg1 = reinterpret_cast< wxWindow * >(argp1);
31621 }
31622 if (obj1) {
31623 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31624 if (!SWIG_IsOK(ecode2)) {
31625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31626 }
31627 arg2 = static_cast< bool >(val2);
31628 }
31629 {
31630 PyThreadState* __tstate = wxPyBeginAllowThreads();
31631 result = (bool)wxSafeYield(arg1,arg2);
31632 wxPyEndAllowThreads(__tstate);
31633 if (PyErr_Occurred()) SWIG_fail;
31634 }
31635 {
31636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31637 }
31638 return resultobj;
31639 fail:
31640 return NULL;
31641 }
31642
31643
31644 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31645 PyObject *resultobj = 0;
31646
31647 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31648 {
31649 PyThreadState* __tstate = wxPyBeginAllowThreads();
31650 wxWakeUpIdle();
31651 wxPyEndAllowThreads(__tstate);
31652 if (PyErr_Occurred()) SWIG_fail;
31653 }
31654 resultobj = SWIG_Py_Void();
31655 return resultobj;
31656 fail:
31657 return NULL;
31658 }
31659
31660
31661 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31662 PyObject *resultobj = 0;
31663 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31664 wxEvent *arg2 = 0 ;
31665 void *argp1 = 0 ;
31666 int res1 = 0 ;
31667 void *argp2 = 0 ;
31668 int res2 = 0 ;
31669 PyObject * obj0 = 0 ;
31670 PyObject * obj1 = 0 ;
31671 char * kwnames[] = {
31672 (char *) "dest",(char *) "event", NULL
31673 };
31674
31675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31677 if (!SWIG_IsOK(res1)) {
31678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31679 }
31680 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31681 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31682 if (!SWIG_IsOK(res2)) {
31683 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31684 }
31685 if (!argp2) {
31686 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31687 }
31688 arg2 = reinterpret_cast< wxEvent * >(argp2);
31689 {
31690 PyThreadState* __tstate = wxPyBeginAllowThreads();
31691 wxPostEvent(arg1,*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_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31703 PyObject *resultobj = 0;
31704
31705 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31706 {
31707 PyThreadState* __tstate = wxPyBeginAllowThreads();
31708 wxApp_CleanUp();
31709 wxPyEndAllowThreads(__tstate);
31710 if (PyErr_Occurred()) SWIG_fail;
31711 }
31712 resultobj = SWIG_Py_Void();
31713 return resultobj;
31714 fail:
31715 return NULL;
31716 }
31717
31718
31719 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31720 PyObject *resultobj = 0;
31721 wxPyApp *result = 0 ;
31722
31723 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31724 {
31725 PyThreadState* __tstate = wxPyBeginAllowThreads();
31726 result = (wxPyApp *)wxPyGetApp();
31727 wxPyEndAllowThreads(__tstate);
31728 if (PyErr_Occurred()) SWIG_fail;
31729 }
31730 {
31731 resultobj = wxPyMake_wxObject(result, 0);
31732 }
31733 return resultobj;
31734 fail:
31735 return NULL;
31736 }
31737
31738
31739 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31740 PyObject *resultobj = 0;
31741 char *arg1 = (char *) 0 ;
31742 int res1 ;
31743 char *buf1 = 0 ;
31744 int alloc1 = 0 ;
31745 PyObject * obj0 = 0 ;
31746 char * kwnames[] = {
31747 (char *) "encoding", NULL
31748 };
31749
31750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31751 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31752 if (!SWIG_IsOK(res1)) {
31753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31754 }
31755 arg1 = buf1;
31756 {
31757 PyThreadState* __tstate = wxPyBeginAllowThreads();
31758 wxSetDefaultPyEncoding((char const *)arg1);
31759 wxPyEndAllowThreads(__tstate);
31760 if (PyErr_Occurred()) SWIG_fail;
31761 }
31762 resultobj = SWIG_Py_Void();
31763 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31764 return resultobj;
31765 fail:
31766 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31767 return NULL;
31768 }
31769
31770
31771 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31772 PyObject *resultobj = 0;
31773 char *result = 0 ;
31774
31775 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31776 {
31777 PyThreadState* __tstate = wxPyBeginAllowThreads();
31778 result = (char *)wxGetDefaultPyEncoding();
31779 wxPyEndAllowThreads(__tstate);
31780 if (PyErr_Occurred()) SWIG_fail;
31781 }
31782 resultobj = SWIG_FromCharPtr(result);
31783 return resultobj;
31784 fail:
31785 return NULL;
31786 }
31787
31788
31789 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31790 PyObject *resultobj = 0;
31791 wxEventLoop *result = 0 ;
31792
31793 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31794 {
31795 PyThreadState* __tstate = wxPyBeginAllowThreads();
31796 result = (wxEventLoop *)new wxEventLoop();
31797 wxPyEndAllowThreads(__tstate);
31798 if (PyErr_Occurred()) SWIG_fail;
31799 }
31800 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31801 return resultobj;
31802 fail:
31803 return NULL;
31804 }
31805
31806
31807 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31808 PyObject *resultobj = 0;
31809 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31810 void *argp1 = 0 ;
31811 int res1 = 0 ;
31812 PyObject *swig_obj[1] ;
31813
31814 if (!args) SWIG_fail;
31815 swig_obj[0] = args;
31816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31817 if (!SWIG_IsOK(res1)) {
31818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31819 }
31820 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31821 {
31822 PyThreadState* __tstate = wxPyBeginAllowThreads();
31823 delete arg1;
31824
31825 wxPyEndAllowThreads(__tstate);
31826 if (PyErr_Occurred()) SWIG_fail;
31827 }
31828 resultobj = SWIG_Py_Void();
31829 return resultobj;
31830 fail:
31831 return NULL;
31832 }
31833
31834
31835 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31836 PyObject *resultobj = 0;
31837 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31838 int result;
31839 void *argp1 = 0 ;
31840 int res1 = 0 ;
31841 PyObject *swig_obj[1] ;
31842
31843 if (!args) SWIG_fail;
31844 swig_obj[0] = args;
31845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31846 if (!SWIG_IsOK(res1)) {
31847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31848 }
31849 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31850 {
31851 PyThreadState* __tstate = wxPyBeginAllowThreads();
31852 result = (int)(arg1)->Run();
31853 wxPyEndAllowThreads(__tstate);
31854 if (PyErr_Occurred()) SWIG_fail;
31855 }
31856 resultobj = SWIG_From_int(static_cast< int >(result));
31857 return resultobj;
31858 fail:
31859 return NULL;
31860 }
31861
31862
31863 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31864 PyObject *resultobj = 0;
31865 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31866 int arg2 = (int) 0 ;
31867 void *argp1 = 0 ;
31868 int res1 = 0 ;
31869 int val2 ;
31870 int ecode2 = 0 ;
31871 PyObject * obj0 = 0 ;
31872 PyObject * obj1 = 0 ;
31873 char * kwnames[] = {
31874 (char *) "self",(char *) "rc", NULL
31875 };
31876
31877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31879 if (!SWIG_IsOK(res1)) {
31880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31881 }
31882 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31883 if (obj1) {
31884 ecode2 = SWIG_AsVal_int(obj1, &val2);
31885 if (!SWIG_IsOK(ecode2)) {
31886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31887 }
31888 arg2 = static_cast< int >(val2);
31889 }
31890 {
31891 PyThreadState* __tstate = wxPyBeginAllowThreads();
31892 (arg1)->Exit(arg2);
31893 wxPyEndAllowThreads(__tstate);
31894 if (PyErr_Occurred()) SWIG_fail;
31895 }
31896 resultobj = SWIG_Py_Void();
31897 return resultobj;
31898 fail:
31899 return NULL;
31900 }
31901
31902
31903 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31904 PyObject *resultobj = 0;
31905 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31906 bool result;
31907 void *argp1 = 0 ;
31908 int res1 = 0 ;
31909 PyObject *swig_obj[1] ;
31910
31911 if (!args) SWIG_fail;
31912 swig_obj[0] = args;
31913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31914 if (!SWIG_IsOK(res1)) {
31915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31916 }
31917 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31918 {
31919 PyThreadState* __tstate = wxPyBeginAllowThreads();
31920 result = (bool)((wxEventLoop const *)arg1)->Pending();
31921 wxPyEndAllowThreads(__tstate);
31922 if (PyErr_Occurred()) SWIG_fail;
31923 }
31924 {
31925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31926 }
31927 return resultobj;
31928 fail:
31929 return NULL;
31930 }
31931
31932
31933 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31934 PyObject *resultobj = 0;
31935 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31936 bool result;
31937 void *argp1 = 0 ;
31938 int res1 = 0 ;
31939 PyObject *swig_obj[1] ;
31940
31941 if (!args) SWIG_fail;
31942 swig_obj[0] = args;
31943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31944 if (!SWIG_IsOK(res1)) {
31945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31946 }
31947 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31948 {
31949 PyThreadState* __tstate = wxPyBeginAllowThreads();
31950 result = (bool)(arg1)->Dispatch();
31951 wxPyEndAllowThreads(__tstate);
31952 if (PyErr_Occurred()) SWIG_fail;
31953 }
31954 {
31955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31956 }
31957 return resultobj;
31958 fail:
31959 return NULL;
31960 }
31961
31962
31963 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31964 PyObject *resultobj = 0;
31965 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31966 bool result;
31967 void *argp1 = 0 ;
31968 int res1 = 0 ;
31969 PyObject *swig_obj[1] ;
31970
31971 if (!args) SWIG_fail;
31972 swig_obj[0] = args;
31973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31974 if (!SWIG_IsOK(res1)) {
31975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31976 }
31977 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31978 {
31979 PyThreadState* __tstate = wxPyBeginAllowThreads();
31980 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31981 wxPyEndAllowThreads(__tstate);
31982 if (PyErr_Occurred()) SWIG_fail;
31983 }
31984 {
31985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31986 }
31987 return resultobj;
31988 fail:
31989 return NULL;
31990 }
31991
31992
31993 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31994 PyObject *resultobj = 0;
31995 wxEventLoop *result = 0 ;
31996
31997 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31998 {
31999 PyThreadState* __tstate = wxPyBeginAllowThreads();
32000 result = (wxEventLoop *)wxEventLoop::GetActive();
32001 wxPyEndAllowThreads(__tstate);
32002 if (PyErr_Occurred()) SWIG_fail;
32003 }
32004 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
32005 return resultobj;
32006 fail:
32007 return NULL;
32008 }
32009
32010
32011 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32012 PyObject *resultobj = 0;
32013 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32014 void *argp1 = 0 ;
32015 int res1 = 0 ;
32016 PyObject * obj0 = 0 ;
32017 char * kwnames[] = {
32018 (char *) "loop", NULL
32019 };
32020
32021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
32022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32023 if (!SWIG_IsOK(res1)) {
32024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32025 }
32026 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32027 {
32028 PyThreadState* __tstate = wxPyBeginAllowThreads();
32029 wxEventLoop::SetActive(arg1);
32030 wxPyEndAllowThreads(__tstate);
32031 if (PyErr_Occurred()) SWIG_fail;
32032 }
32033 resultobj = SWIG_Py_Void();
32034 return resultobj;
32035 fail:
32036 return NULL;
32037 }
32038
32039
32040 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32041 PyObject *obj;
32042 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32043 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
32044 return SWIG_Py_Void();
32045 }
32046
32047 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32048 return SWIG_Python_InitShadowInstance(args);
32049 }
32050
32051 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32052 PyObject *resultobj = 0;
32053 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32054 wxEventLoopActivator *result = 0 ;
32055 void *argp1 = 0 ;
32056 int res1 = 0 ;
32057 PyObject * obj0 = 0 ;
32058 char * kwnames[] = {
32059 (char *) "evtLoop", NULL
32060 };
32061
32062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
32063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32064 if (!SWIG_IsOK(res1)) {
32065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32066 }
32067 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32068 {
32069 PyThreadState* __tstate = wxPyBeginAllowThreads();
32070 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
32071 wxPyEndAllowThreads(__tstate);
32072 if (PyErr_Occurred()) SWIG_fail;
32073 }
32074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
32075 return resultobj;
32076 fail:
32077 return NULL;
32078 }
32079
32080
32081 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32082 PyObject *resultobj = 0;
32083 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
32084 void *argp1 = 0 ;
32085 int res1 = 0 ;
32086 PyObject *swig_obj[1] ;
32087
32088 if (!args) SWIG_fail;
32089 swig_obj[0] = args;
32090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
32091 if (!SWIG_IsOK(res1)) {
32092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
32093 }
32094 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
32095 {
32096 PyThreadState* __tstate = wxPyBeginAllowThreads();
32097 delete arg1;
32098
32099 wxPyEndAllowThreads(__tstate);
32100 if (PyErr_Occurred()) SWIG_fail;
32101 }
32102 resultobj = SWIG_Py_Void();
32103 return resultobj;
32104 fail:
32105 return NULL;
32106 }
32107
32108
32109 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32110 PyObject *obj;
32111 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32112 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
32113 return SWIG_Py_Void();
32114 }
32115
32116 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32117 return SWIG_Python_InitShadowInstance(args);
32118 }
32119
32120 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32121 PyObject *resultobj = 0;
32122 int arg1 = (int) 0 ;
32123 int arg2 = (int) 0 ;
32124 int arg3 = (int) 0 ;
32125 wxAcceleratorEntry *result = 0 ;
32126 int val1 ;
32127 int ecode1 = 0 ;
32128 int val2 ;
32129 int ecode2 = 0 ;
32130 int val3 ;
32131 int ecode3 = 0 ;
32132 PyObject * obj0 = 0 ;
32133 PyObject * obj1 = 0 ;
32134 PyObject * obj2 = 0 ;
32135 char * kwnames[] = {
32136 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
32137 };
32138
32139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32140 if (obj0) {
32141 ecode1 = SWIG_AsVal_int(obj0, &val1);
32142 if (!SWIG_IsOK(ecode1)) {
32143 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
32144 }
32145 arg1 = static_cast< int >(val1);
32146 }
32147 if (obj1) {
32148 ecode2 = SWIG_AsVal_int(obj1, &val2);
32149 if (!SWIG_IsOK(ecode2)) {
32150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
32151 }
32152 arg2 = static_cast< int >(val2);
32153 }
32154 if (obj2) {
32155 ecode3 = SWIG_AsVal_int(obj2, &val3);
32156 if (!SWIG_IsOK(ecode3)) {
32157 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
32158 }
32159 arg3 = static_cast< int >(val3);
32160 }
32161 {
32162 PyThreadState* __tstate = wxPyBeginAllowThreads();
32163 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
32164 wxPyEndAllowThreads(__tstate);
32165 if (PyErr_Occurred()) SWIG_fail;
32166 }
32167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
32168 return resultobj;
32169 fail:
32170 return NULL;
32171 }
32172
32173
32174 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32175 PyObject *resultobj = 0;
32176 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32177 void *argp1 = 0 ;
32178 int res1 = 0 ;
32179 PyObject *swig_obj[1] ;
32180
32181 if (!args) SWIG_fail;
32182 swig_obj[0] = args;
32183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
32184 if (!SWIG_IsOK(res1)) {
32185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32186 }
32187 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32188 {
32189 PyThreadState* __tstate = wxPyBeginAllowThreads();
32190 delete arg1;
32191
32192 wxPyEndAllowThreads(__tstate);
32193 if (PyErr_Occurred()) SWIG_fail;
32194 }
32195 resultobj = SWIG_Py_Void();
32196 return resultobj;
32197 fail:
32198 return NULL;
32199 }
32200
32201
32202 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32203 PyObject *resultobj = 0;
32204 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32205 int arg2 ;
32206 int arg3 ;
32207 int arg4 ;
32208 void *argp1 = 0 ;
32209 int res1 = 0 ;
32210 int val2 ;
32211 int ecode2 = 0 ;
32212 int val3 ;
32213 int ecode3 = 0 ;
32214 int val4 ;
32215 int ecode4 = 0 ;
32216 PyObject * obj0 = 0 ;
32217 PyObject * obj1 = 0 ;
32218 PyObject * obj2 = 0 ;
32219 PyObject * obj3 = 0 ;
32220 char * kwnames[] = {
32221 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32222 };
32223
32224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32226 if (!SWIG_IsOK(res1)) {
32227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32228 }
32229 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32230 ecode2 = SWIG_AsVal_int(obj1, &val2);
32231 if (!SWIG_IsOK(ecode2)) {
32232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32233 }
32234 arg2 = static_cast< int >(val2);
32235 ecode3 = SWIG_AsVal_int(obj2, &val3);
32236 if (!SWIG_IsOK(ecode3)) {
32237 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32238 }
32239 arg3 = static_cast< int >(val3);
32240 ecode4 = SWIG_AsVal_int(obj3, &val4);
32241 if (!SWIG_IsOK(ecode4)) {
32242 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32243 }
32244 arg4 = static_cast< int >(val4);
32245 {
32246 PyThreadState* __tstate = wxPyBeginAllowThreads();
32247 (arg1)->Set(arg2,arg3,arg4);
32248 wxPyEndAllowThreads(__tstate);
32249 if (PyErr_Occurred()) SWIG_fail;
32250 }
32251 resultobj = SWIG_Py_Void();
32252 return resultobj;
32253 fail:
32254 return NULL;
32255 }
32256
32257
32258 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32259 PyObject *resultobj = 0;
32260 wxString *arg1 = 0 ;
32261 wxAcceleratorEntry *result = 0 ;
32262 bool temp1 = false ;
32263 PyObject * obj0 = 0 ;
32264 char * kwnames[] = {
32265 (char *) "str", NULL
32266 };
32267
32268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32269 {
32270 arg1 = wxString_in_helper(obj0);
32271 if (arg1 == NULL) SWIG_fail;
32272 temp1 = true;
32273 }
32274 {
32275 PyThreadState* __tstate = wxPyBeginAllowThreads();
32276 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32277 wxPyEndAllowThreads(__tstate);
32278 if (PyErr_Occurred()) SWIG_fail;
32279 }
32280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32281 {
32282 if (temp1)
32283 delete arg1;
32284 }
32285 return resultobj;
32286 fail:
32287 {
32288 if (temp1)
32289 delete arg1;
32290 }
32291 return NULL;
32292 }
32293
32294
32295 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32296 PyObject *resultobj = 0;
32297 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32298 int result;
32299 void *argp1 = 0 ;
32300 int res1 = 0 ;
32301 PyObject *swig_obj[1] ;
32302
32303 if (!args) SWIG_fail;
32304 swig_obj[0] = args;
32305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32306 if (!SWIG_IsOK(res1)) {
32307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32308 }
32309 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32310 {
32311 PyThreadState* __tstate = wxPyBeginAllowThreads();
32312 result = (int)(arg1)->GetFlags();
32313 wxPyEndAllowThreads(__tstate);
32314 if (PyErr_Occurred()) SWIG_fail;
32315 }
32316 resultobj = SWIG_From_int(static_cast< int >(result));
32317 return resultobj;
32318 fail:
32319 return NULL;
32320 }
32321
32322
32323 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32324 PyObject *resultobj = 0;
32325 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32326 int result;
32327 void *argp1 = 0 ;
32328 int res1 = 0 ;
32329 PyObject *swig_obj[1] ;
32330
32331 if (!args) SWIG_fail;
32332 swig_obj[0] = args;
32333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32334 if (!SWIG_IsOK(res1)) {
32335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32336 }
32337 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32338 {
32339 PyThreadState* __tstate = wxPyBeginAllowThreads();
32340 result = (int)(arg1)->GetKeyCode();
32341 wxPyEndAllowThreads(__tstate);
32342 if (PyErr_Occurred()) SWIG_fail;
32343 }
32344 resultobj = SWIG_From_int(static_cast< int >(result));
32345 return resultobj;
32346 fail:
32347 return NULL;
32348 }
32349
32350
32351 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32352 PyObject *resultobj = 0;
32353 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32354 int result;
32355 void *argp1 = 0 ;
32356 int res1 = 0 ;
32357 PyObject *swig_obj[1] ;
32358
32359 if (!args) SWIG_fail;
32360 swig_obj[0] = args;
32361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32362 if (!SWIG_IsOK(res1)) {
32363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32364 }
32365 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32366 {
32367 PyThreadState* __tstate = wxPyBeginAllowThreads();
32368 result = (int)(arg1)->GetCommand();
32369 wxPyEndAllowThreads(__tstate);
32370 if (PyErr_Occurred()) SWIG_fail;
32371 }
32372 resultobj = SWIG_From_int(static_cast< int >(result));
32373 return resultobj;
32374 fail:
32375 return NULL;
32376 }
32377
32378
32379 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32380 PyObject *resultobj = 0;
32381 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32382 bool result;
32383 void *argp1 = 0 ;
32384 int res1 = 0 ;
32385 PyObject *swig_obj[1] ;
32386
32387 if (!args) SWIG_fail;
32388 swig_obj[0] = args;
32389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32390 if (!SWIG_IsOK(res1)) {
32391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32392 }
32393 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32394 {
32395 PyThreadState* __tstate = wxPyBeginAllowThreads();
32396 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32397 wxPyEndAllowThreads(__tstate);
32398 if (PyErr_Occurred()) SWIG_fail;
32399 }
32400 {
32401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32402 }
32403 return resultobj;
32404 fail:
32405 return NULL;
32406 }
32407
32408
32409 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32410 PyObject *resultobj = 0;
32411 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32412 wxString result;
32413 void *argp1 = 0 ;
32414 int res1 = 0 ;
32415 PyObject *swig_obj[1] ;
32416
32417 if (!args) SWIG_fail;
32418 swig_obj[0] = args;
32419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32420 if (!SWIG_IsOK(res1)) {
32421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32422 }
32423 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32424 {
32425 PyThreadState* __tstate = wxPyBeginAllowThreads();
32426 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32427 wxPyEndAllowThreads(__tstate);
32428 if (PyErr_Occurred()) SWIG_fail;
32429 }
32430 {
32431 #if wxUSE_UNICODE
32432 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32433 #else
32434 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32435 #endif
32436 }
32437 return resultobj;
32438 fail:
32439 return NULL;
32440 }
32441
32442
32443 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32444 PyObject *resultobj = 0;
32445 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32446 wxString *arg2 = 0 ;
32447 bool result;
32448 void *argp1 = 0 ;
32449 int res1 = 0 ;
32450 bool temp2 = false ;
32451 PyObject * obj0 = 0 ;
32452 PyObject * obj1 = 0 ;
32453 char * kwnames[] = {
32454 (char *) "self",(char *) "str", NULL
32455 };
32456
32457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32459 if (!SWIG_IsOK(res1)) {
32460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32461 }
32462 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32463 {
32464 arg2 = wxString_in_helper(obj1);
32465 if (arg2 == NULL) SWIG_fail;
32466 temp2 = true;
32467 }
32468 {
32469 PyThreadState* __tstate = wxPyBeginAllowThreads();
32470 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32471 wxPyEndAllowThreads(__tstate);
32472 if (PyErr_Occurred()) SWIG_fail;
32473 }
32474 {
32475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32476 }
32477 {
32478 if (temp2)
32479 delete arg2;
32480 }
32481 return resultobj;
32482 fail:
32483 {
32484 if (temp2)
32485 delete arg2;
32486 }
32487 return NULL;
32488 }
32489
32490
32491 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32492 PyObject *obj;
32493 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32494 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32495 return SWIG_Py_Void();
32496 }
32497
32498 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32499 return SWIG_Python_InitShadowInstance(args);
32500 }
32501
32502 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32503 PyObject *resultobj = 0;
32504 int arg1 ;
32505 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32506 wxAcceleratorTable *result = 0 ;
32507 PyObject * obj0 = 0 ;
32508 char * kwnames[] = {
32509 (char *) "n", NULL
32510 };
32511
32512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32513 {
32514 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32515 if (arg2) arg1 = PyList_Size(obj0);
32516 else arg1 = 0;
32517 }
32518 {
32519 PyThreadState* __tstate = wxPyBeginAllowThreads();
32520 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32521 wxPyEndAllowThreads(__tstate);
32522 if (PyErr_Occurred()) SWIG_fail;
32523 }
32524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32525 return resultobj;
32526 fail:
32527 return NULL;
32528 }
32529
32530
32531 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32532 PyObject *resultobj = 0;
32533 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32534 void *argp1 = 0 ;
32535 int res1 = 0 ;
32536 PyObject *swig_obj[1] ;
32537
32538 if (!args) SWIG_fail;
32539 swig_obj[0] = args;
32540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32541 if (!SWIG_IsOK(res1)) {
32542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32543 }
32544 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32545 {
32546 PyThreadState* __tstate = wxPyBeginAllowThreads();
32547 delete arg1;
32548
32549 wxPyEndAllowThreads(__tstate);
32550 if (PyErr_Occurred()) SWIG_fail;
32551 }
32552 resultobj = SWIG_Py_Void();
32553 return resultobj;
32554 fail:
32555 return NULL;
32556 }
32557
32558
32559 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32560 PyObject *resultobj = 0;
32561 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32562 bool result;
32563 void *argp1 = 0 ;
32564 int res1 = 0 ;
32565 PyObject *swig_obj[1] ;
32566
32567 if (!args) SWIG_fail;
32568 swig_obj[0] = args;
32569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32570 if (!SWIG_IsOK(res1)) {
32571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32572 }
32573 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32574 {
32575 PyThreadState* __tstate = wxPyBeginAllowThreads();
32576 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32577 wxPyEndAllowThreads(__tstate);
32578 if (PyErr_Occurred()) SWIG_fail;
32579 }
32580 {
32581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32582 }
32583 return resultobj;
32584 fail:
32585 return NULL;
32586 }
32587
32588
32589 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32590 PyObject *obj;
32591 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32592 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32593 return SWIG_Py_Void();
32594 }
32595
32596 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32597 return SWIG_Python_InitShadowInstance(args);
32598 }
32599
32600 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32601 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32602 return 1;
32603 }
32604
32605
32606 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32607 PyObject *pyobj = 0;
32608
32609 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32610 return pyobj;
32611 }
32612
32613
32614 SWIGINTERN int PanelNameStr_set(PyObject *) {
32615 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32616 return 1;
32617 }
32618
32619
32620 SWIGINTERN PyObject *PanelNameStr_get(void) {
32621 PyObject *pyobj = 0;
32622
32623 {
32624 #if wxUSE_UNICODE
32625 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32626 #else
32627 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32628 #endif
32629 }
32630 return pyobj;
32631 }
32632
32633
32634 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32635 PyObject *resultobj = 0;
32636 wxVisualAttributes *result = 0 ;
32637
32638 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32639 {
32640 PyThreadState* __tstate = wxPyBeginAllowThreads();
32641 result = (wxVisualAttributes *)new_wxVisualAttributes();
32642 wxPyEndAllowThreads(__tstate);
32643 if (PyErr_Occurred()) SWIG_fail;
32644 }
32645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32646 return resultobj;
32647 fail:
32648 return NULL;
32649 }
32650
32651
32652 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32653 PyObject *resultobj = 0;
32654 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32655 void *argp1 = 0 ;
32656 int res1 = 0 ;
32657 PyObject *swig_obj[1] ;
32658
32659 if (!args) SWIG_fail;
32660 swig_obj[0] = args;
32661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32662 if (!SWIG_IsOK(res1)) {
32663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32664 }
32665 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32666 {
32667 PyThreadState* __tstate = wxPyBeginAllowThreads();
32668 delete_wxVisualAttributes(arg1);
32669
32670 wxPyEndAllowThreads(__tstate);
32671 if (PyErr_Occurred()) SWIG_fail;
32672 }
32673 resultobj = SWIG_Py_Void();
32674 return resultobj;
32675 fail:
32676 return NULL;
32677 }
32678
32679
32680 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32681 PyObject *resultobj = 0;
32682 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32683 wxFont *arg2 = (wxFont *) 0 ;
32684 void *argp1 = 0 ;
32685 int res1 = 0 ;
32686 void *argp2 = 0 ;
32687 int res2 = 0 ;
32688 PyObject *swig_obj[2] ;
32689
32690 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32692 if (!SWIG_IsOK(res1)) {
32693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32694 }
32695 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32696 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32697 if (!SWIG_IsOK(res2)) {
32698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32699 }
32700 arg2 = reinterpret_cast< wxFont * >(argp2);
32701 if (arg1) (arg1)->font = *arg2;
32702
32703 resultobj = SWIG_Py_Void();
32704 return resultobj;
32705 fail:
32706 return NULL;
32707 }
32708
32709
32710 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32711 PyObject *resultobj = 0;
32712 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32713 wxFont *result = 0 ;
32714 void *argp1 = 0 ;
32715 int res1 = 0 ;
32716 PyObject *swig_obj[1] ;
32717
32718 if (!args) SWIG_fail;
32719 swig_obj[0] = args;
32720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32721 if (!SWIG_IsOK(res1)) {
32722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32723 }
32724 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32725 result = (wxFont *)& ((arg1)->font);
32726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32727 return resultobj;
32728 fail:
32729 return NULL;
32730 }
32731
32732
32733 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32734 PyObject *resultobj = 0;
32735 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32736 wxColour *arg2 = (wxColour *) 0 ;
32737 void *argp1 = 0 ;
32738 int res1 = 0 ;
32739 void *argp2 = 0 ;
32740 int res2 = 0 ;
32741 PyObject *swig_obj[2] ;
32742
32743 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32745 if (!SWIG_IsOK(res1)) {
32746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32747 }
32748 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32749 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32750 if (!SWIG_IsOK(res2)) {
32751 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32752 }
32753 arg2 = reinterpret_cast< wxColour * >(argp2);
32754 if (arg1) (arg1)->colFg = *arg2;
32755
32756 resultobj = SWIG_Py_Void();
32757 return resultobj;
32758 fail:
32759 return NULL;
32760 }
32761
32762
32763 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32764 PyObject *resultobj = 0;
32765 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32766 wxColour *result = 0 ;
32767 void *argp1 = 0 ;
32768 int res1 = 0 ;
32769 PyObject *swig_obj[1] ;
32770
32771 if (!args) SWIG_fail;
32772 swig_obj[0] = args;
32773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32774 if (!SWIG_IsOK(res1)) {
32775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32776 }
32777 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32778 result = (wxColour *)& ((arg1)->colFg);
32779 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32780 return resultobj;
32781 fail:
32782 return NULL;
32783 }
32784
32785
32786 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32787 PyObject *resultobj = 0;
32788 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32789 wxColour *arg2 = (wxColour *) 0 ;
32790 void *argp1 = 0 ;
32791 int res1 = 0 ;
32792 void *argp2 = 0 ;
32793 int res2 = 0 ;
32794 PyObject *swig_obj[2] ;
32795
32796 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32798 if (!SWIG_IsOK(res1)) {
32799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32800 }
32801 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32802 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32803 if (!SWIG_IsOK(res2)) {
32804 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32805 }
32806 arg2 = reinterpret_cast< wxColour * >(argp2);
32807 if (arg1) (arg1)->colBg = *arg2;
32808
32809 resultobj = SWIG_Py_Void();
32810 return resultobj;
32811 fail:
32812 return NULL;
32813 }
32814
32815
32816 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32817 PyObject *resultobj = 0;
32818 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32819 wxColour *result = 0 ;
32820 void *argp1 = 0 ;
32821 int res1 = 0 ;
32822 PyObject *swig_obj[1] ;
32823
32824 if (!args) SWIG_fail;
32825 swig_obj[0] = args;
32826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32827 if (!SWIG_IsOK(res1)) {
32828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32829 }
32830 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32831 result = (wxColour *)& ((arg1)->colBg);
32832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32833 return resultobj;
32834 fail:
32835 return NULL;
32836 }
32837
32838
32839 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32840 PyObject *obj;
32841 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32842 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32843 return SWIG_Py_Void();
32844 }
32845
32846 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32847 return SWIG_Python_InitShadowInstance(args);
32848 }
32849
32850 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32851 PyObject *resultobj = 0;
32852 wxWindow *arg1 = (wxWindow *) 0 ;
32853 int arg2 = (int) (int)-1 ;
32854 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32855 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32856 wxSize const &arg4_defvalue = wxDefaultSize ;
32857 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32858 long arg5 = (long) 0 ;
32859 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32860 wxString *arg6 = (wxString *) &arg6_defvalue ;
32861 wxWindow *result = 0 ;
32862 void *argp1 = 0 ;
32863 int res1 = 0 ;
32864 int val2 ;
32865 int ecode2 = 0 ;
32866 wxPoint temp3 ;
32867 wxSize temp4 ;
32868 long val5 ;
32869 int ecode5 = 0 ;
32870 bool temp6 = false ;
32871 PyObject * obj0 = 0 ;
32872 PyObject * obj1 = 0 ;
32873 PyObject * obj2 = 0 ;
32874 PyObject * obj3 = 0 ;
32875 PyObject * obj4 = 0 ;
32876 PyObject * obj5 = 0 ;
32877 char * kwnames[] = {
32878 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32879 };
32880
32881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32883 if (!SWIG_IsOK(res1)) {
32884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32885 }
32886 arg1 = reinterpret_cast< wxWindow * >(argp1);
32887 if (obj1) {
32888 ecode2 = SWIG_AsVal_int(obj1, &val2);
32889 if (!SWIG_IsOK(ecode2)) {
32890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32891 }
32892 arg2 = static_cast< int >(val2);
32893 }
32894 if (obj2) {
32895 {
32896 arg3 = &temp3;
32897 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32898 }
32899 }
32900 if (obj3) {
32901 {
32902 arg4 = &temp4;
32903 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32904 }
32905 }
32906 if (obj4) {
32907 ecode5 = SWIG_AsVal_long(obj4, &val5);
32908 if (!SWIG_IsOK(ecode5)) {
32909 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32910 }
32911 arg5 = static_cast< long >(val5);
32912 }
32913 if (obj5) {
32914 {
32915 arg6 = wxString_in_helper(obj5);
32916 if (arg6 == NULL) SWIG_fail;
32917 temp6 = true;
32918 }
32919 }
32920 {
32921 if (!wxPyCheckForApp()) SWIG_fail;
32922 PyThreadState* __tstate = wxPyBeginAllowThreads();
32923 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32924 wxPyEndAllowThreads(__tstate);
32925 if (PyErr_Occurred()) SWIG_fail;
32926 }
32927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32928 {
32929 if (temp6)
32930 delete arg6;
32931 }
32932 return resultobj;
32933 fail:
32934 {
32935 if (temp6)
32936 delete arg6;
32937 }
32938 return NULL;
32939 }
32940
32941
32942 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32943 PyObject *resultobj = 0;
32944 wxWindow *result = 0 ;
32945
32946 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32947 {
32948 if (!wxPyCheckForApp()) SWIG_fail;
32949 PyThreadState* __tstate = wxPyBeginAllowThreads();
32950 result = (wxWindow *)new wxWindow();
32951 wxPyEndAllowThreads(__tstate);
32952 if (PyErr_Occurred()) SWIG_fail;
32953 }
32954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32955 return resultobj;
32956 fail:
32957 return NULL;
32958 }
32959
32960
32961 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32962 PyObject *resultobj = 0;
32963 wxWindow *arg1 = (wxWindow *) 0 ;
32964 wxWindow *arg2 = (wxWindow *) 0 ;
32965 int arg3 = (int) (int)-1 ;
32966 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32967 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32968 wxSize const &arg5_defvalue = wxDefaultSize ;
32969 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32970 long arg6 = (long) 0 ;
32971 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32972 wxString *arg7 = (wxString *) &arg7_defvalue ;
32973 bool result;
32974 void *argp1 = 0 ;
32975 int res1 = 0 ;
32976 void *argp2 = 0 ;
32977 int res2 = 0 ;
32978 int val3 ;
32979 int ecode3 = 0 ;
32980 wxPoint temp4 ;
32981 wxSize temp5 ;
32982 long val6 ;
32983 int ecode6 = 0 ;
32984 bool temp7 = false ;
32985 PyObject * obj0 = 0 ;
32986 PyObject * obj1 = 0 ;
32987 PyObject * obj2 = 0 ;
32988 PyObject * obj3 = 0 ;
32989 PyObject * obj4 = 0 ;
32990 PyObject * obj5 = 0 ;
32991 PyObject * obj6 = 0 ;
32992 char * kwnames[] = {
32993 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32994 };
32995
32996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32998 if (!SWIG_IsOK(res1)) {
32999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
33000 }
33001 arg1 = reinterpret_cast< wxWindow * >(argp1);
33002 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33003 if (!SWIG_IsOK(res2)) {
33004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
33005 }
33006 arg2 = reinterpret_cast< wxWindow * >(argp2);
33007 if (obj2) {
33008 ecode3 = SWIG_AsVal_int(obj2, &val3);
33009 if (!SWIG_IsOK(ecode3)) {
33010 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
33011 }
33012 arg3 = static_cast< int >(val3);
33013 }
33014 if (obj3) {
33015 {
33016 arg4 = &temp4;
33017 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
33018 }
33019 }
33020 if (obj4) {
33021 {
33022 arg5 = &temp5;
33023 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
33024 }
33025 }
33026 if (obj5) {
33027 ecode6 = SWIG_AsVal_long(obj5, &val6);
33028 if (!SWIG_IsOK(ecode6)) {
33029 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
33030 }
33031 arg6 = static_cast< long >(val6);
33032 }
33033 if (obj6) {
33034 {
33035 arg7 = wxString_in_helper(obj6);
33036 if (arg7 == NULL) SWIG_fail;
33037 temp7 = true;
33038 }
33039 }
33040 {
33041 PyThreadState* __tstate = wxPyBeginAllowThreads();
33042 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
33043 wxPyEndAllowThreads(__tstate);
33044 if (PyErr_Occurred()) SWIG_fail;
33045 }
33046 {
33047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33048 }
33049 {
33050 if (temp7)
33051 delete arg7;
33052 }
33053 return resultobj;
33054 fail:
33055 {
33056 if (temp7)
33057 delete arg7;
33058 }
33059 return NULL;
33060 }
33061
33062
33063 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33064 PyObject *resultobj = 0;
33065 wxWindow *arg1 = (wxWindow *) 0 ;
33066 bool arg2 = (bool) false ;
33067 bool result;
33068 void *argp1 = 0 ;
33069 int res1 = 0 ;
33070 bool val2 ;
33071 int ecode2 = 0 ;
33072 PyObject * obj0 = 0 ;
33073 PyObject * obj1 = 0 ;
33074 char * kwnames[] = {
33075 (char *) "self",(char *) "force", NULL
33076 };
33077
33078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
33079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33080 if (!SWIG_IsOK(res1)) {
33081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
33082 }
33083 arg1 = reinterpret_cast< wxWindow * >(argp1);
33084 if (obj1) {
33085 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33086 if (!SWIG_IsOK(ecode2)) {
33087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
33088 }
33089 arg2 = static_cast< bool >(val2);
33090 }
33091 {
33092 PyThreadState* __tstate = wxPyBeginAllowThreads();
33093 result = (bool)(arg1)->Close(arg2);
33094 wxPyEndAllowThreads(__tstate);
33095 if (PyErr_Occurred()) SWIG_fail;
33096 }
33097 {
33098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33099 }
33100 return resultobj;
33101 fail:
33102 return NULL;
33103 }
33104
33105
33106 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33107 PyObject *resultobj = 0;
33108 wxWindow *arg1 = (wxWindow *) 0 ;
33109 bool result;
33110 void *argp1 = 0 ;
33111 int res1 = 0 ;
33112 PyObject *swig_obj[1] ;
33113
33114 if (!args) SWIG_fail;
33115 swig_obj[0] = args;
33116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33117 if (!SWIG_IsOK(res1)) {
33118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
33119 }
33120 arg1 = reinterpret_cast< wxWindow * >(argp1);
33121 {
33122 PyThreadState* __tstate = wxPyBeginAllowThreads();
33123 result = (bool)(arg1)->Destroy();
33124 wxPyEndAllowThreads(__tstate);
33125 if (PyErr_Occurred()) SWIG_fail;
33126 }
33127 {
33128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33129 }
33130 return resultobj;
33131 fail:
33132 return NULL;
33133 }
33134
33135
33136 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33137 PyObject *resultobj = 0;
33138 wxWindow *arg1 = (wxWindow *) 0 ;
33139 bool result;
33140 void *argp1 = 0 ;
33141 int res1 = 0 ;
33142 PyObject *swig_obj[1] ;
33143
33144 if (!args) SWIG_fail;
33145 swig_obj[0] = args;
33146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33147 if (!SWIG_IsOK(res1)) {
33148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33149 }
33150 arg1 = reinterpret_cast< wxWindow * >(argp1);
33151 {
33152 PyThreadState* __tstate = wxPyBeginAllowThreads();
33153 result = (bool)(arg1)->DestroyChildren();
33154 wxPyEndAllowThreads(__tstate);
33155 if (PyErr_Occurred()) SWIG_fail;
33156 }
33157 {
33158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33159 }
33160 return resultobj;
33161 fail:
33162 return NULL;
33163 }
33164
33165
33166 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33167 PyObject *resultobj = 0;
33168 wxWindow *arg1 = (wxWindow *) 0 ;
33169 bool result;
33170 void *argp1 = 0 ;
33171 int res1 = 0 ;
33172 PyObject *swig_obj[1] ;
33173
33174 if (!args) SWIG_fail;
33175 swig_obj[0] = args;
33176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33177 if (!SWIG_IsOK(res1)) {
33178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33179 }
33180 arg1 = reinterpret_cast< wxWindow * >(argp1);
33181 {
33182 PyThreadState* __tstate = wxPyBeginAllowThreads();
33183 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33184 wxPyEndAllowThreads(__tstate);
33185 if (PyErr_Occurred()) SWIG_fail;
33186 }
33187 {
33188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33189 }
33190 return resultobj;
33191 fail:
33192 return NULL;
33193 }
33194
33195
33196 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33197 PyObject *resultobj = 0;
33198 wxWindow *arg1 = (wxWindow *) 0 ;
33199 wxString *arg2 = 0 ;
33200 void *argp1 = 0 ;
33201 int res1 = 0 ;
33202 bool temp2 = false ;
33203 PyObject * obj0 = 0 ;
33204 PyObject * obj1 = 0 ;
33205 char * kwnames[] = {
33206 (char *) "self",(char *) "label", NULL
33207 };
33208
33209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33211 if (!SWIG_IsOK(res1)) {
33212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33213 }
33214 arg1 = reinterpret_cast< wxWindow * >(argp1);
33215 {
33216 arg2 = wxString_in_helper(obj1);
33217 if (arg2 == NULL) SWIG_fail;
33218 temp2 = true;
33219 }
33220 {
33221 PyThreadState* __tstate = wxPyBeginAllowThreads();
33222 (arg1)->SetLabel((wxString const &)*arg2);
33223 wxPyEndAllowThreads(__tstate);
33224 if (PyErr_Occurred()) SWIG_fail;
33225 }
33226 resultobj = SWIG_Py_Void();
33227 {
33228 if (temp2)
33229 delete arg2;
33230 }
33231 return resultobj;
33232 fail:
33233 {
33234 if (temp2)
33235 delete arg2;
33236 }
33237 return NULL;
33238 }
33239
33240
33241 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33242 PyObject *resultobj = 0;
33243 wxWindow *arg1 = (wxWindow *) 0 ;
33244 wxString result;
33245 void *argp1 = 0 ;
33246 int res1 = 0 ;
33247 PyObject *swig_obj[1] ;
33248
33249 if (!args) SWIG_fail;
33250 swig_obj[0] = args;
33251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33252 if (!SWIG_IsOK(res1)) {
33253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33254 }
33255 arg1 = reinterpret_cast< wxWindow * >(argp1);
33256 {
33257 PyThreadState* __tstate = wxPyBeginAllowThreads();
33258 result = ((wxWindow const *)arg1)->GetLabel();
33259 wxPyEndAllowThreads(__tstate);
33260 if (PyErr_Occurred()) SWIG_fail;
33261 }
33262 {
33263 #if wxUSE_UNICODE
33264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33265 #else
33266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33267 #endif
33268 }
33269 return resultobj;
33270 fail:
33271 return NULL;
33272 }
33273
33274
33275 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33276 PyObject *resultobj = 0;
33277 wxWindow *arg1 = (wxWindow *) 0 ;
33278 wxString *arg2 = 0 ;
33279 void *argp1 = 0 ;
33280 int res1 = 0 ;
33281 bool temp2 = false ;
33282 PyObject * obj0 = 0 ;
33283 PyObject * obj1 = 0 ;
33284 char * kwnames[] = {
33285 (char *) "self",(char *) "name", NULL
33286 };
33287
33288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33290 if (!SWIG_IsOK(res1)) {
33291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33292 }
33293 arg1 = reinterpret_cast< wxWindow * >(argp1);
33294 {
33295 arg2 = wxString_in_helper(obj1);
33296 if (arg2 == NULL) SWIG_fail;
33297 temp2 = true;
33298 }
33299 {
33300 PyThreadState* __tstate = wxPyBeginAllowThreads();
33301 (arg1)->SetName((wxString const &)*arg2);
33302 wxPyEndAllowThreads(__tstate);
33303 if (PyErr_Occurred()) SWIG_fail;
33304 }
33305 resultobj = SWIG_Py_Void();
33306 {
33307 if (temp2)
33308 delete arg2;
33309 }
33310 return resultobj;
33311 fail:
33312 {
33313 if (temp2)
33314 delete arg2;
33315 }
33316 return NULL;
33317 }
33318
33319
33320 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33321 PyObject *resultobj = 0;
33322 wxWindow *arg1 = (wxWindow *) 0 ;
33323 wxString result;
33324 void *argp1 = 0 ;
33325 int res1 = 0 ;
33326 PyObject *swig_obj[1] ;
33327
33328 if (!args) SWIG_fail;
33329 swig_obj[0] = args;
33330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33331 if (!SWIG_IsOK(res1)) {
33332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33333 }
33334 arg1 = reinterpret_cast< wxWindow * >(argp1);
33335 {
33336 PyThreadState* __tstate = wxPyBeginAllowThreads();
33337 result = ((wxWindow const *)arg1)->GetName();
33338 wxPyEndAllowThreads(__tstate);
33339 if (PyErr_Occurred()) SWIG_fail;
33340 }
33341 {
33342 #if wxUSE_UNICODE
33343 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33344 #else
33345 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33346 #endif
33347 }
33348 return resultobj;
33349 fail:
33350 return NULL;
33351 }
33352
33353
33354 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33355 PyObject *resultobj = 0;
33356 wxWindow *arg1 = (wxWindow *) 0 ;
33357 wxWindowVariant arg2 ;
33358 void *argp1 = 0 ;
33359 int res1 = 0 ;
33360 int val2 ;
33361 int ecode2 = 0 ;
33362 PyObject * obj0 = 0 ;
33363 PyObject * obj1 = 0 ;
33364 char * kwnames[] = {
33365 (char *) "self",(char *) "variant", NULL
33366 };
33367
33368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33370 if (!SWIG_IsOK(res1)) {
33371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33372 }
33373 arg1 = reinterpret_cast< wxWindow * >(argp1);
33374 ecode2 = SWIG_AsVal_int(obj1, &val2);
33375 if (!SWIG_IsOK(ecode2)) {
33376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33377 }
33378 arg2 = static_cast< wxWindowVariant >(val2);
33379 {
33380 PyThreadState* __tstate = wxPyBeginAllowThreads();
33381 (arg1)->SetWindowVariant(arg2);
33382 wxPyEndAllowThreads(__tstate);
33383 if (PyErr_Occurred()) SWIG_fail;
33384 }
33385 resultobj = SWIG_Py_Void();
33386 return resultobj;
33387 fail:
33388 return NULL;
33389 }
33390
33391
33392 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33393 PyObject *resultobj = 0;
33394 wxWindow *arg1 = (wxWindow *) 0 ;
33395 wxWindowVariant result;
33396 void *argp1 = 0 ;
33397 int res1 = 0 ;
33398 PyObject *swig_obj[1] ;
33399
33400 if (!args) SWIG_fail;
33401 swig_obj[0] = args;
33402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33403 if (!SWIG_IsOK(res1)) {
33404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33405 }
33406 arg1 = reinterpret_cast< wxWindow * >(argp1);
33407 {
33408 PyThreadState* __tstate = wxPyBeginAllowThreads();
33409 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33410 wxPyEndAllowThreads(__tstate);
33411 if (PyErr_Occurred()) SWIG_fail;
33412 }
33413 resultobj = SWIG_From_int(static_cast< int >(result));
33414 return resultobj;
33415 fail:
33416 return NULL;
33417 }
33418
33419
33420 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33421 PyObject *resultobj = 0;
33422 wxWindow *arg1 = (wxWindow *) 0 ;
33423 int arg2 ;
33424 void *argp1 = 0 ;
33425 int res1 = 0 ;
33426 int val2 ;
33427 int ecode2 = 0 ;
33428 PyObject * obj0 = 0 ;
33429 PyObject * obj1 = 0 ;
33430 char * kwnames[] = {
33431 (char *) "self",(char *) "winid", NULL
33432 };
33433
33434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33436 if (!SWIG_IsOK(res1)) {
33437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33438 }
33439 arg1 = reinterpret_cast< wxWindow * >(argp1);
33440 ecode2 = SWIG_AsVal_int(obj1, &val2);
33441 if (!SWIG_IsOK(ecode2)) {
33442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33443 }
33444 arg2 = static_cast< int >(val2);
33445 {
33446 PyThreadState* __tstate = wxPyBeginAllowThreads();
33447 (arg1)->SetId(arg2);
33448 wxPyEndAllowThreads(__tstate);
33449 if (PyErr_Occurred()) SWIG_fail;
33450 }
33451 resultobj = SWIG_Py_Void();
33452 return resultobj;
33453 fail:
33454 return NULL;
33455 }
33456
33457
33458 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33459 PyObject *resultobj = 0;
33460 wxWindow *arg1 = (wxWindow *) 0 ;
33461 int result;
33462 void *argp1 = 0 ;
33463 int res1 = 0 ;
33464 PyObject *swig_obj[1] ;
33465
33466 if (!args) SWIG_fail;
33467 swig_obj[0] = args;
33468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33469 if (!SWIG_IsOK(res1)) {
33470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33471 }
33472 arg1 = reinterpret_cast< wxWindow * >(argp1);
33473 {
33474 PyThreadState* __tstate = wxPyBeginAllowThreads();
33475 result = (int)((wxWindow const *)arg1)->GetId();
33476 wxPyEndAllowThreads(__tstate);
33477 if (PyErr_Occurred()) SWIG_fail;
33478 }
33479 resultobj = SWIG_From_int(static_cast< int >(result));
33480 return resultobj;
33481 fail:
33482 return NULL;
33483 }
33484
33485
33486 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33487 PyObject *resultobj = 0;
33488 int result;
33489
33490 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33491 {
33492 PyThreadState* __tstate = wxPyBeginAllowThreads();
33493 result = (int)wxWindow::NewControlId();
33494 wxPyEndAllowThreads(__tstate);
33495 if (PyErr_Occurred()) SWIG_fail;
33496 }
33497 resultobj = SWIG_From_int(static_cast< int >(result));
33498 return resultobj;
33499 fail:
33500 return NULL;
33501 }
33502
33503
33504 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33505 PyObject *resultobj = 0;
33506 int arg1 ;
33507 int result;
33508 int val1 ;
33509 int ecode1 = 0 ;
33510 PyObject * obj0 = 0 ;
33511 char * kwnames[] = {
33512 (char *) "winid", NULL
33513 };
33514
33515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33516 ecode1 = SWIG_AsVal_int(obj0, &val1);
33517 if (!SWIG_IsOK(ecode1)) {
33518 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33519 }
33520 arg1 = static_cast< int >(val1);
33521 {
33522 PyThreadState* __tstate = wxPyBeginAllowThreads();
33523 result = (int)wxWindow::NextControlId(arg1);
33524 wxPyEndAllowThreads(__tstate);
33525 if (PyErr_Occurred()) SWIG_fail;
33526 }
33527 resultobj = SWIG_From_int(static_cast< int >(result));
33528 return resultobj;
33529 fail:
33530 return NULL;
33531 }
33532
33533
33534 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33535 PyObject *resultobj = 0;
33536 int arg1 ;
33537 int result;
33538 int val1 ;
33539 int ecode1 = 0 ;
33540 PyObject * obj0 = 0 ;
33541 char * kwnames[] = {
33542 (char *) "winid", NULL
33543 };
33544
33545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33546 ecode1 = SWIG_AsVal_int(obj0, &val1);
33547 if (!SWIG_IsOK(ecode1)) {
33548 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33549 }
33550 arg1 = static_cast< int >(val1);
33551 {
33552 PyThreadState* __tstate = wxPyBeginAllowThreads();
33553 result = (int)wxWindow::PrevControlId(arg1);
33554 wxPyEndAllowThreads(__tstate);
33555 if (PyErr_Occurred()) SWIG_fail;
33556 }
33557 resultobj = SWIG_From_int(static_cast< int >(result));
33558 return resultobj;
33559 fail:
33560 return NULL;
33561 }
33562
33563
33564 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33565 PyObject *resultobj = 0;
33566 wxWindow *arg1 = (wxWindow *) 0 ;
33567 wxLayoutDirection result;
33568 void *argp1 = 0 ;
33569 int res1 = 0 ;
33570 PyObject *swig_obj[1] ;
33571
33572 if (!args) SWIG_fail;
33573 swig_obj[0] = args;
33574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33575 if (!SWIG_IsOK(res1)) {
33576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33577 }
33578 arg1 = reinterpret_cast< wxWindow * >(argp1);
33579 {
33580 PyThreadState* __tstate = wxPyBeginAllowThreads();
33581 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33582 wxPyEndAllowThreads(__tstate);
33583 if (PyErr_Occurred()) SWIG_fail;
33584 }
33585 resultobj = SWIG_From_int(static_cast< int >(result));
33586 return resultobj;
33587 fail:
33588 return NULL;
33589 }
33590
33591
33592 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33593 PyObject *resultobj = 0;
33594 wxWindow *arg1 = (wxWindow *) 0 ;
33595 wxLayoutDirection arg2 ;
33596 void *argp1 = 0 ;
33597 int res1 = 0 ;
33598 int val2 ;
33599 int ecode2 = 0 ;
33600 PyObject * obj0 = 0 ;
33601 PyObject * obj1 = 0 ;
33602 char * kwnames[] = {
33603 (char *) "self",(char *) "dir", NULL
33604 };
33605
33606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33608 if (!SWIG_IsOK(res1)) {
33609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33610 }
33611 arg1 = reinterpret_cast< wxWindow * >(argp1);
33612 ecode2 = SWIG_AsVal_int(obj1, &val2);
33613 if (!SWIG_IsOK(ecode2)) {
33614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33615 }
33616 arg2 = static_cast< wxLayoutDirection >(val2);
33617 {
33618 PyThreadState* __tstate = wxPyBeginAllowThreads();
33619 (arg1)->SetLayoutDirection(arg2);
33620 wxPyEndAllowThreads(__tstate);
33621 if (PyErr_Occurred()) SWIG_fail;
33622 }
33623 resultobj = SWIG_Py_Void();
33624 return resultobj;
33625 fail:
33626 return NULL;
33627 }
33628
33629
33630 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33631 PyObject *resultobj = 0;
33632 wxWindow *arg1 = (wxWindow *) 0 ;
33633 int arg2 ;
33634 int arg3 ;
33635 int arg4 ;
33636 int result;
33637 void *argp1 = 0 ;
33638 int res1 = 0 ;
33639 int val2 ;
33640 int ecode2 = 0 ;
33641 int val3 ;
33642 int ecode3 = 0 ;
33643 int val4 ;
33644 int ecode4 = 0 ;
33645 PyObject * obj0 = 0 ;
33646 PyObject * obj1 = 0 ;
33647 PyObject * obj2 = 0 ;
33648 PyObject * obj3 = 0 ;
33649 char * kwnames[] = {
33650 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33651 };
33652
33653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33655 if (!SWIG_IsOK(res1)) {
33656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33657 }
33658 arg1 = reinterpret_cast< wxWindow * >(argp1);
33659 ecode2 = SWIG_AsVal_int(obj1, &val2);
33660 if (!SWIG_IsOK(ecode2)) {
33661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33662 }
33663 arg2 = static_cast< int >(val2);
33664 ecode3 = SWIG_AsVal_int(obj2, &val3);
33665 if (!SWIG_IsOK(ecode3)) {
33666 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33667 }
33668 arg3 = static_cast< int >(val3);
33669 ecode4 = SWIG_AsVal_int(obj3, &val4);
33670 if (!SWIG_IsOK(ecode4)) {
33671 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33672 }
33673 arg4 = static_cast< int >(val4);
33674 {
33675 PyThreadState* __tstate = wxPyBeginAllowThreads();
33676 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33677 wxPyEndAllowThreads(__tstate);
33678 if (PyErr_Occurred()) SWIG_fail;
33679 }
33680 resultobj = SWIG_From_int(static_cast< int >(result));
33681 return resultobj;
33682 fail:
33683 return NULL;
33684 }
33685
33686
33687 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33688 PyObject *resultobj = 0;
33689 wxWindow *arg1 = (wxWindow *) 0 ;
33690 wxSize *arg2 = 0 ;
33691 void *argp1 = 0 ;
33692 int res1 = 0 ;
33693 wxSize temp2 ;
33694 PyObject * obj0 = 0 ;
33695 PyObject * obj1 = 0 ;
33696 char * kwnames[] = {
33697 (char *) "self",(char *) "size", NULL
33698 };
33699
33700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) 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_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33704 }
33705 arg1 = reinterpret_cast< wxWindow * >(argp1);
33706 {
33707 arg2 = &temp2;
33708 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33709 }
33710 {
33711 PyThreadState* __tstate = wxPyBeginAllowThreads();
33712 (arg1)->SetSize((wxSize const &)*arg2);
33713 wxPyEndAllowThreads(__tstate);
33714 if (PyErr_Occurred()) SWIG_fail;
33715 }
33716 resultobj = SWIG_Py_Void();
33717 return resultobj;
33718 fail:
33719 return NULL;
33720 }
33721
33722
33723 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33724 PyObject *resultobj = 0;
33725 wxWindow *arg1 = (wxWindow *) 0 ;
33726 int arg2 ;
33727 int arg3 ;
33728 int arg4 ;
33729 int arg5 ;
33730 int arg6 = (int) wxSIZE_AUTO ;
33731 void *argp1 = 0 ;
33732 int res1 = 0 ;
33733 int val2 ;
33734 int ecode2 = 0 ;
33735 int val3 ;
33736 int ecode3 = 0 ;
33737 int val4 ;
33738 int ecode4 = 0 ;
33739 int val5 ;
33740 int ecode5 = 0 ;
33741 int val6 ;
33742 int ecode6 = 0 ;
33743 PyObject * obj0 = 0 ;
33744 PyObject * obj1 = 0 ;
33745 PyObject * obj2 = 0 ;
33746 PyObject * obj3 = 0 ;
33747 PyObject * obj4 = 0 ;
33748 PyObject * obj5 = 0 ;
33749 char * kwnames[] = {
33750 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33751 };
33752
33753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33755 if (!SWIG_IsOK(res1)) {
33756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33757 }
33758 arg1 = reinterpret_cast< wxWindow * >(argp1);
33759 ecode2 = SWIG_AsVal_int(obj1, &val2);
33760 if (!SWIG_IsOK(ecode2)) {
33761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33762 }
33763 arg2 = static_cast< int >(val2);
33764 ecode3 = SWIG_AsVal_int(obj2, &val3);
33765 if (!SWIG_IsOK(ecode3)) {
33766 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33767 }
33768 arg3 = static_cast< int >(val3);
33769 ecode4 = SWIG_AsVal_int(obj3, &val4);
33770 if (!SWIG_IsOK(ecode4)) {
33771 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33772 }
33773 arg4 = static_cast< int >(val4);
33774 ecode5 = SWIG_AsVal_int(obj4, &val5);
33775 if (!SWIG_IsOK(ecode5)) {
33776 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33777 }
33778 arg5 = static_cast< int >(val5);
33779 if (obj5) {
33780 ecode6 = SWIG_AsVal_int(obj5, &val6);
33781 if (!SWIG_IsOK(ecode6)) {
33782 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33783 }
33784 arg6 = static_cast< int >(val6);
33785 }
33786 {
33787 PyThreadState* __tstate = wxPyBeginAllowThreads();
33788 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33789 wxPyEndAllowThreads(__tstate);
33790 if (PyErr_Occurred()) SWIG_fail;
33791 }
33792 resultobj = SWIG_Py_Void();
33793 return resultobj;
33794 fail:
33795 return NULL;
33796 }
33797
33798
33799 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33800 PyObject *resultobj = 0;
33801 wxWindow *arg1 = (wxWindow *) 0 ;
33802 wxRect *arg2 = 0 ;
33803 int arg3 = (int) wxSIZE_AUTO ;
33804 void *argp1 = 0 ;
33805 int res1 = 0 ;
33806 wxRect temp2 ;
33807 int val3 ;
33808 int ecode3 = 0 ;
33809 PyObject * obj0 = 0 ;
33810 PyObject * obj1 = 0 ;
33811 PyObject * obj2 = 0 ;
33812 char * kwnames[] = {
33813 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33814 };
33815
33816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33818 if (!SWIG_IsOK(res1)) {
33819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33820 }
33821 arg1 = reinterpret_cast< wxWindow * >(argp1);
33822 {
33823 arg2 = &temp2;
33824 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33825 }
33826 if (obj2) {
33827 ecode3 = SWIG_AsVal_int(obj2, &val3);
33828 if (!SWIG_IsOK(ecode3)) {
33829 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33830 }
33831 arg3 = static_cast< int >(val3);
33832 }
33833 {
33834 PyThreadState* __tstate = wxPyBeginAllowThreads();
33835 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33836 wxPyEndAllowThreads(__tstate);
33837 if (PyErr_Occurred()) SWIG_fail;
33838 }
33839 resultobj = SWIG_Py_Void();
33840 return resultobj;
33841 fail:
33842 return NULL;
33843 }
33844
33845
33846 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33847 PyObject *resultobj = 0;
33848 wxWindow *arg1 = (wxWindow *) 0 ;
33849 int arg2 ;
33850 int arg3 ;
33851 void *argp1 = 0 ;
33852 int res1 = 0 ;
33853 int val2 ;
33854 int ecode2 = 0 ;
33855 int val3 ;
33856 int ecode3 = 0 ;
33857 PyObject * obj0 = 0 ;
33858 PyObject * obj1 = 0 ;
33859 PyObject * obj2 = 0 ;
33860 char * kwnames[] = {
33861 (char *) "self",(char *) "width",(char *) "height", NULL
33862 };
33863
33864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33866 if (!SWIG_IsOK(res1)) {
33867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33868 }
33869 arg1 = reinterpret_cast< wxWindow * >(argp1);
33870 ecode2 = SWIG_AsVal_int(obj1, &val2);
33871 if (!SWIG_IsOK(ecode2)) {
33872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33873 }
33874 arg2 = static_cast< int >(val2);
33875 ecode3 = SWIG_AsVal_int(obj2, &val3);
33876 if (!SWIG_IsOK(ecode3)) {
33877 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33878 }
33879 arg3 = static_cast< int >(val3);
33880 {
33881 PyThreadState* __tstate = wxPyBeginAllowThreads();
33882 (arg1)->SetSize(arg2,arg3);
33883 wxPyEndAllowThreads(__tstate);
33884 if (PyErr_Occurred()) SWIG_fail;
33885 }
33886 resultobj = SWIG_Py_Void();
33887 return resultobj;
33888 fail:
33889 return NULL;
33890 }
33891
33892
33893 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33894 PyObject *resultobj = 0;
33895 wxWindow *arg1 = (wxWindow *) 0 ;
33896 wxPoint *arg2 = 0 ;
33897 int arg3 = (int) wxSIZE_USE_EXISTING ;
33898 void *argp1 = 0 ;
33899 int res1 = 0 ;
33900 wxPoint temp2 ;
33901 int val3 ;
33902 int ecode3 = 0 ;
33903 PyObject * obj0 = 0 ;
33904 PyObject * obj1 = 0 ;
33905 PyObject * obj2 = 0 ;
33906 char * kwnames[] = {
33907 (char *) "self",(char *) "pt",(char *) "flags", NULL
33908 };
33909
33910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33912 if (!SWIG_IsOK(res1)) {
33913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33914 }
33915 arg1 = reinterpret_cast< wxWindow * >(argp1);
33916 {
33917 arg2 = &temp2;
33918 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33919 }
33920 if (obj2) {
33921 ecode3 = SWIG_AsVal_int(obj2, &val3);
33922 if (!SWIG_IsOK(ecode3)) {
33923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33924 }
33925 arg3 = static_cast< int >(val3);
33926 }
33927 {
33928 PyThreadState* __tstate = wxPyBeginAllowThreads();
33929 (arg1)->Move((wxPoint const &)*arg2,arg3);
33930 wxPyEndAllowThreads(__tstate);
33931 if (PyErr_Occurred()) SWIG_fail;
33932 }
33933 resultobj = SWIG_Py_Void();
33934 return resultobj;
33935 fail:
33936 return NULL;
33937 }
33938
33939
33940 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33941 PyObject *resultobj = 0;
33942 wxWindow *arg1 = (wxWindow *) 0 ;
33943 int arg2 ;
33944 int arg3 ;
33945 int arg4 = (int) wxSIZE_USE_EXISTING ;
33946 void *argp1 = 0 ;
33947 int res1 = 0 ;
33948 int val2 ;
33949 int ecode2 = 0 ;
33950 int val3 ;
33951 int ecode3 = 0 ;
33952 int val4 ;
33953 int ecode4 = 0 ;
33954 PyObject * obj0 = 0 ;
33955 PyObject * obj1 = 0 ;
33956 PyObject * obj2 = 0 ;
33957 PyObject * obj3 = 0 ;
33958 char * kwnames[] = {
33959 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33960 };
33961
33962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33964 if (!SWIG_IsOK(res1)) {
33965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33966 }
33967 arg1 = reinterpret_cast< wxWindow * >(argp1);
33968 ecode2 = SWIG_AsVal_int(obj1, &val2);
33969 if (!SWIG_IsOK(ecode2)) {
33970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33971 }
33972 arg2 = static_cast< int >(val2);
33973 ecode3 = SWIG_AsVal_int(obj2, &val3);
33974 if (!SWIG_IsOK(ecode3)) {
33975 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33976 }
33977 arg3 = static_cast< int >(val3);
33978 if (obj3) {
33979 ecode4 = SWIG_AsVal_int(obj3, &val4);
33980 if (!SWIG_IsOK(ecode4)) {
33981 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33982 }
33983 arg4 = static_cast< int >(val4);
33984 }
33985 {
33986 PyThreadState* __tstate = wxPyBeginAllowThreads();
33987 (arg1)->Move(arg2,arg3,arg4);
33988 wxPyEndAllowThreads(__tstate);
33989 if (PyErr_Occurred()) SWIG_fail;
33990 }
33991 resultobj = SWIG_Py_Void();
33992 return resultobj;
33993 fail:
33994 return NULL;
33995 }
33996
33997
33998 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33999 PyObject *resultobj = 0;
34000 wxWindow *arg1 = (wxWindow *) 0 ;
34001 wxSize const &arg2_defvalue = wxDefaultSize ;
34002 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
34003 void *argp1 = 0 ;
34004 int res1 = 0 ;
34005 wxSize temp2 ;
34006 PyObject * obj0 = 0 ;
34007 PyObject * obj1 = 0 ;
34008 char * kwnames[] = {
34009 (char *) "self",(char *) "size", NULL
34010 };
34011
34012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
34013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34014 if (!SWIG_IsOK(res1)) {
34015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34016 }
34017 arg1 = reinterpret_cast< wxWindow * >(argp1);
34018 if (obj1) {
34019 {
34020 arg2 = &temp2;
34021 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34022 }
34023 }
34024 {
34025 PyThreadState* __tstate = wxPyBeginAllowThreads();
34026 (arg1)->SetInitialSize((wxSize const &)*arg2);
34027 wxPyEndAllowThreads(__tstate);
34028 if (PyErr_Occurred()) SWIG_fail;
34029 }
34030 resultobj = SWIG_Py_Void();
34031 return resultobj;
34032 fail:
34033 return NULL;
34034 }
34035
34036
34037 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34038 PyObject *resultobj = 0;
34039 wxWindow *arg1 = (wxWindow *) 0 ;
34040 void *argp1 = 0 ;
34041 int res1 = 0 ;
34042 PyObject *swig_obj[1] ;
34043
34044 if (!args) SWIG_fail;
34045 swig_obj[0] = args;
34046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34047 if (!SWIG_IsOK(res1)) {
34048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
34049 }
34050 arg1 = reinterpret_cast< wxWindow * >(argp1);
34051 {
34052 PyThreadState* __tstate = wxPyBeginAllowThreads();
34053 (arg1)->Raise();
34054 wxPyEndAllowThreads(__tstate);
34055 if (PyErr_Occurred()) SWIG_fail;
34056 }
34057 resultobj = SWIG_Py_Void();
34058 return resultobj;
34059 fail:
34060 return NULL;
34061 }
34062
34063
34064 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34065 PyObject *resultobj = 0;
34066 wxWindow *arg1 = (wxWindow *) 0 ;
34067 void *argp1 = 0 ;
34068 int res1 = 0 ;
34069 PyObject *swig_obj[1] ;
34070
34071 if (!args) SWIG_fail;
34072 swig_obj[0] = args;
34073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34074 if (!SWIG_IsOK(res1)) {
34075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
34076 }
34077 arg1 = reinterpret_cast< wxWindow * >(argp1);
34078 {
34079 PyThreadState* __tstate = wxPyBeginAllowThreads();
34080 (arg1)->Lower();
34081 wxPyEndAllowThreads(__tstate);
34082 if (PyErr_Occurred()) SWIG_fail;
34083 }
34084 resultobj = SWIG_Py_Void();
34085 return resultobj;
34086 fail:
34087 return NULL;
34088 }
34089
34090
34091 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34092 PyObject *resultobj = 0;
34093 wxWindow *arg1 = (wxWindow *) 0 ;
34094 wxSize *arg2 = 0 ;
34095 void *argp1 = 0 ;
34096 int res1 = 0 ;
34097 wxSize temp2 ;
34098 PyObject * obj0 = 0 ;
34099 PyObject * obj1 = 0 ;
34100 char * kwnames[] = {
34101 (char *) "self",(char *) "size", NULL
34102 };
34103
34104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
34105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34106 if (!SWIG_IsOK(res1)) {
34107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34108 }
34109 arg1 = reinterpret_cast< wxWindow * >(argp1);
34110 {
34111 arg2 = &temp2;
34112 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34113 }
34114 {
34115 PyThreadState* __tstate = wxPyBeginAllowThreads();
34116 (arg1)->SetClientSize((wxSize const &)*arg2);
34117 wxPyEndAllowThreads(__tstate);
34118 if (PyErr_Occurred()) SWIG_fail;
34119 }
34120 resultobj = SWIG_Py_Void();
34121 return resultobj;
34122 fail:
34123 return NULL;
34124 }
34125
34126
34127 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34128 PyObject *resultobj = 0;
34129 wxWindow *arg1 = (wxWindow *) 0 ;
34130 int arg2 ;
34131 int arg3 ;
34132 void *argp1 = 0 ;
34133 int res1 = 0 ;
34134 int val2 ;
34135 int ecode2 = 0 ;
34136 int val3 ;
34137 int ecode3 = 0 ;
34138 PyObject * obj0 = 0 ;
34139 PyObject * obj1 = 0 ;
34140 PyObject * obj2 = 0 ;
34141 char * kwnames[] = {
34142 (char *) "self",(char *) "width",(char *) "height", NULL
34143 };
34144
34145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34147 if (!SWIG_IsOK(res1)) {
34148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34149 }
34150 arg1 = reinterpret_cast< wxWindow * >(argp1);
34151 ecode2 = SWIG_AsVal_int(obj1, &val2);
34152 if (!SWIG_IsOK(ecode2)) {
34153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
34154 }
34155 arg2 = static_cast< int >(val2);
34156 ecode3 = SWIG_AsVal_int(obj2, &val3);
34157 if (!SWIG_IsOK(ecode3)) {
34158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
34159 }
34160 arg3 = static_cast< int >(val3);
34161 {
34162 PyThreadState* __tstate = wxPyBeginAllowThreads();
34163 (arg1)->SetClientSize(arg2,arg3);
34164 wxPyEndAllowThreads(__tstate);
34165 if (PyErr_Occurred()) SWIG_fail;
34166 }
34167 resultobj = SWIG_Py_Void();
34168 return resultobj;
34169 fail:
34170 return NULL;
34171 }
34172
34173
34174 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34175 PyObject *resultobj = 0;
34176 wxWindow *arg1 = (wxWindow *) 0 ;
34177 wxRect *arg2 = 0 ;
34178 void *argp1 = 0 ;
34179 int res1 = 0 ;
34180 wxRect temp2 ;
34181 PyObject * obj0 = 0 ;
34182 PyObject * obj1 = 0 ;
34183 char * kwnames[] = {
34184 (char *) "self",(char *) "rect", NULL
34185 };
34186
34187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34189 if (!SWIG_IsOK(res1)) {
34190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34191 }
34192 arg1 = reinterpret_cast< wxWindow * >(argp1);
34193 {
34194 arg2 = &temp2;
34195 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34196 }
34197 {
34198 PyThreadState* __tstate = wxPyBeginAllowThreads();
34199 (arg1)->SetClientSize((wxRect const &)*arg2);
34200 wxPyEndAllowThreads(__tstate);
34201 if (PyErr_Occurred()) SWIG_fail;
34202 }
34203 resultobj = SWIG_Py_Void();
34204 return resultobj;
34205 fail:
34206 return NULL;
34207 }
34208
34209
34210 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34211 PyObject *resultobj = 0;
34212 wxWindow *arg1 = (wxWindow *) 0 ;
34213 wxPoint result;
34214 void *argp1 = 0 ;
34215 int res1 = 0 ;
34216 PyObject *swig_obj[1] ;
34217
34218 if (!args) SWIG_fail;
34219 swig_obj[0] = args;
34220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34221 if (!SWIG_IsOK(res1)) {
34222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34223 }
34224 arg1 = reinterpret_cast< wxWindow * >(argp1);
34225 {
34226 PyThreadState* __tstate = wxPyBeginAllowThreads();
34227 result = ((wxWindow const *)arg1)->GetPosition();
34228 wxPyEndAllowThreads(__tstate);
34229 if (PyErr_Occurred()) SWIG_fail;
34230 }
34231 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34232 return resultobj;
34233 fail:
34234 return NULL;
34235 }
34236
34237
34238 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34239 PyObject *resultobj = 0;
34240 wxWindow *arg1 = (wxWindow *) 0 ;
34241 int *arg2 = (int *) 0 ;
34242 int *arg3 = (int *) 0 ;
34243 void *argp1 = 0 ;
34244 int res1 = 0 ;
34245 int temp2 ;
34246 int res2 = SWIG_TMPOBJ ;
34247 int temp3 ;
34248 int res3 = SWIG_TMPOBJ ;
34249 PyObject *swig_obj[1] ;
34250
34251 arg2 = &temp2;
34252 arg3 = &temp3;
34253 if (!args) SWIG_fail;
34254 swig_obj[0] = args;
34255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34256 if (!SWIG_IsOK(res1)) {
34257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34258 }
34259 arg1 = reinterpret_cast< wxWindow * >(argp1);
34260 {
34261 PyThreadState* __tstate = wxPyBeginAllowThreads();
34262 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34263 wxPyEndAllowThreads(__tstate);
34264 if (PyErr_Occurred()) SWIG_fail;
34265 }
34266 resultobj = SWIG_Py_Void();
34267 if (SWIG_IsTmpObj(res2)) {
34268 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34269 } else {
34270 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34271 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34272 }
34273 if (SWIG_IsTmpObj(res3)) {
34274 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34275 } else {
34276 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34277 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34278 }
34279 return resultobj;
34280 fail:
34281 return NULL;
34282 }
34283
34284
34285 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34286 PyObject *resultobj = 0;
34287 wxWindow *arg1 = (wxWindow *) 0 ;
34288 wxPoint result;
34289 void *argp1 = 0 ;
34290 int res1 = 0 ;
34291 PyObject *swig_obj[1] ;
34292
34293 if (!args) SWIG_fail;
34294 swig_obj[0] = args;
34295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34296 if (!SWIG_IsOK(res1)) {
34297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34298 }
34299 arg1 = reinterpret_cast< wxWindow * >(argp1);
34300 {
34301 PyThreadState* __tstate = wxPyBeginAllowThreads();
34302 result = ((wxWindow const *)arg1)->GetScreenPosition();
34303 wxPyEndAllowThreads(__tstate);
34304 if (PyErr_Occurred()) SWIG_fail;
34305 }
34306 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34307 return resultobj;
34308 fail:
34309 return NULL;
34310 }
34311
34312
34313 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34314 PyObject *resultobj = 0;
34315 wxWindow *arg1 = (wxWindow *) 0 ;
34316 int *arg2 = (int *) 0 ;
34317 int *arg3 = (int *) 0 ;
34318 void *argp1 = 0 ;
34319 int res1 = 0 ;
34320 int temp2 ;
34321 int res2 = SWIG_TMPOBJ ;
34322 int temp3 ;
34323 int res3 = SWIG_TMPOBJ ;
34324 PyObject *swig_obj[1] ;
34325
34326 arg2 = &temp2;
34327 arg3 = &temp3;
34328 if (!args) SWIG_fail;
34329 swig_obj[0] = args;
34330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34331 if (!SWIG_IsOK(res1)) {
34332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34333 }
34334 arg1 = reinterpret_cast< wxWindow * >(argp1);
34335 {
34336 PyThreadState* __tstate = wxPyBeginAllowThreads();
34337 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34338 wxPyEndAllowThreads(__tstate);
34339 if (PyErr_Occurred()) SWIG_fail;
34340 }
34341 resultobj = SWIG_Py_Void();
34342 if (SWIG_IsTmpObj(res2)) {
34343 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34344 } else {
34345 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34346 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34347 }
34348 if (SWIG_IsTmpObj(res3)) {
34349 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34350 } else {
34351 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34352 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34353 }
34354 return resultobj;
34355 fail:
34356 return NULL;
34357 }
34358
34359
34360 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34361 PyObject *resultobj = 0;
34362 wxWindow *arg1 = (wxWindow *) 0 ;
34363 wxRect result;
34364 void *argp1 = 0 ;
34365 int res1 = 0 ;
34366 PyObject *swig_obj[1] ;
34367
34368 if (!args) SWIG_fail;
34369 swig_obj[0] = args;
34370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34371 if (!SWIG_IsOK(res1)) {
34372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34373 }
34374 arg1 = reinterpret_cast< wxWindow * >(argp1);
34375 {
34376 PyThreadState* __tstate = wxPyBeginAllowThreads();
34377 result = ((wxWindow const *)arg1)->GetScreenRect();
34378 wxPyEndAllowThreads(__tstate);
34379 if (PyErr_Occurred()) SWIG_fail;
34380 }
34381 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34382 return resultobj;
34383 fail:
34384 return NULL;
34385 }
34386
34387
34388 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34389 PyObject *resultobj = 0;
34390 wxWindow *arg1 = (wxWindow *) 0 ;
34391 wxSize result;
34392 void *argp1 = 0 ;
34393 int res1 = 0 ;
34394 PyObject *swig_obj[1] ;
34395
34396 if (!args) SWIG_fail;
34397 swig_obj[0] = args;
34398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34399 if (!SWIG_IsOK(res1)) {
34400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34401 }
34402 arg1 = reinterpret_cast< wxWindow * >(argp1);
34403 {
34404 PyThreadState* __tstate = wxPyBeginAllowThreads();
34405 result = ((wxWindow const *)arg1)->GetSize();
34406 wxPyEndAllowThreads(__tstate);
34407 if (PyErr_Occurred()) SWIG_fail;
34408 }
34409 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34410 return resultobj;
34411 fail:
34412 return NULL;
34413 }
34414
34415
34416 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34417 PyObject *resultobj = 0;
34418 wxWindow *arg1 = (wxWindow *) 0 ;
34419 int *arg2 = (int *) 0 ;
34420 int *arg3 = (int *) 0 ;
34421 void *argp1 = 0 ;
34422 int res1 = 0 ;
34423 int temp2 ;
34424 int res2 = SWIG_TMPOBJ ;
34425 int temp3 ;
34426 int res3 = SWIG_TMPOBJ ;
34427 PyObject *swig_obj[1] ;
34428
34429 arg2 = &temp2;
34430 arg3 = &temp3;
34431 if (!args) SWIG_fail;
34432 swig_obj[0] = args;
34433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34434 if (!SWIG_IsOK(res1)) {
34435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34436 }
34437 arg1 = reinterpret_cast< wxWindow * >(argp1);
34438 {
34439 PyThreadState* __tstate = wxPyBeginAllowThreads();
34440 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34441 wxPyEndAllowThreads(__tstate);
34442 if (PyErr_Occurred()) SWIG_fail;
34443 }
34444 resultobj = SWIG_Py_Void();
34445 if (SWIG_IsTmpObj(res2)) {
34446 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34447 } else {
34448 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34449 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34450 }
34451 if (SWIG_IsTmpObj(res3)) {
34452 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34453 } else {
34454 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34455 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34456 }
34457 return resultobj;
34458 fail:
34459 return NULL;
34460 }
34461
34462
34463 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34464 PyObject *resultobj = 0;
34465 wxWindow *arg1 = (wxWindow *) 0 ;
34466 wxRect result;
34467 void *argp1 = 0 ;
34468 int res1 = 0 ;
34469 PyObject *swig_obj[1] ;
34470
34471 if (!args) SWIG_fail;
34472 swig_obj[0] = args;
34473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34474 if (!SWIG_IsOK(res1)) {
34475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34476 }
34477 arg1 = reinterpret_cast< wxWindow * >(argp1);
34478 {
34479 PyThreadState* __tstate = wxPyBeginAllowThreads();
34480 result = ((wxWindow const *)arg1)->GetRect();
34481 wxPyEndAllowThreads(__tstate);
34482 if (PyErr_Occurred()) SWIG_fail;
34483 }
34484 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34485 return resultobj;
34486 fail:
34487 return NULL;
34488 }
34489
34490
34491 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34492 PyObject *resultobj = 0;
34493 wxWindow *arg1 = (wxWindow *) 0 ;
34494 wxSize result;
34495 void *argp1 = 0 ;
34496 int res1 = 0 ;
34497 PyObject *swig_obj[1] ;
34498
34499 if (!args) SWIG_fail;
34500 swig_obj[0] = args;
34501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34502 if (!SWIG_IsOK(res1)) {
34503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34504 }
34505 arg1 = reinterpret_cast< wxWindow * >(argp1);
34506 {
34507 PyThreadState* __tstate = wxPyBeginAllowThreads();
34508 result = ((wxWindow const *)arg1)->GetClientSize();
34509 wxPyEndAllowThreads(__tstate);
34510 if (PyErr_Occurred()) SWIG_fail;
34511 }
34512 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34513 return resultobj;
34514 fail:
34515 return NULL;
34516 }
34517
34518
34519 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34520 PyObject *resultobj = 0;
34521 wxWindow *arg1 = (wxWindow *) 0 ;
34522 int *arg2 = (int *) 0 ;
34523 int *arg3 = (int *) 0 ;
34524 void *argp1 = 0 ;
34525 int res1 = 0 ;
34526 int temp2 ;
34527 int res2 = SWIG_TMPOBJ ;
34528 int temp3 ;
34529 int res3 = SWIG_TMPOBJ ;
34530 PyObject *swig_obj[1] ;
34531
34532 arg2 = &temp2;
34533 arg3 = &temp3;
34534 if (!args) SWIG_fail;
34535 swig_obj[0] = args;
34536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34537 if (!SWIG_IsOK(res1)) {
34538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34539 }
34540 arg1 = reinterpret_cast< wxWindow * >(argp1);
34541 {
34542 PyThreadState* __tstate = wxPyBeginAllowThreads();
34543 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34544 wxPyEndAllowThreads(__tstate);
34545 if (PyErr_Occurred()) SWIG_fail;
34546 }
34547 resultobj = SWIG_Py_Void();
34548 if (SWIG_IsTmpObj(res2)) {
34549 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34550 } else {
34551 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34552 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34553 }
34554 if (SWIG_IsTmpObj(res3)) {
34555 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34556 } else {
34557 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34558 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34559 }
34560 return resultobj;
34561 fail:
34562 return NULL;
34563 }
34564
34565
34566 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34567 PyObject *resultobj = 0;
34568 wxWindow *arg1 = (wxWindow *) 0 ;
34569 wxPoint result;
34570 void *argp1 = 0 ;
34571 int res1 = 0 ;
34572 PyObject *swig_obj[1] ;
34573
34574 if (!args) SWIG_fail;
34575 swig_obj[0] = args;
34576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34577 if (!SWIG_IsOK(res1)) {
34578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34579 }
34580 arg1 = reinterpret_cast< wxWindow * >(argp1);
34581 {
34582 PyThreadState* __tstate = wxPyBeginAllowThreads();
34583 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34584 wxPyEndAllowThreads(__tstate);
34585 if (PyErr_Occurred()) SWIG_fail;
34586 }
34587 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34588 return resultobj;
34589 fail:
34590 return NULL;
34591 }
34592
34593
34594 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34595 PyObject *resultobj = 0;
34596 wxWindow *arg1 = (wxWindow *) 0 ;
34597 wxRect result;
34598 void *argp1 = 0 ;
34599 int res1 = 0 ;
34600 PyObject *swig_obj[1] ;
34601
34602 if (!args) SWIG_fail;
34603 swig_obj[0] = args;
34604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34605 if (!SWIG_IsOK(res1)) {
34606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34607 }
34608 arg1 = reinterpret_cast< wxWindow * >(argp1);
34609 {
34610 PyThreadState* __tstate = wxPyBeginAllowThreads();
34611 result = ((wxWindow const *)arg1)->GetClientRect();
34612 wxPyEndAllowThreads(__tstate);
34613 if (PyErr_Occurred()) SWIG_fail;
34614 }
34615 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34616 return resultobj;
34617 fail:
34618 return NULL;
34619 }
34620
34621
34622 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34623 PyObject *resultobj = 0;
34624 wxWindow *arg1 = (wxWindow *) 0 ;
34625 wxSize result;
34626 void *argp1 = 0 ;
34627 int res1 = 0 ;
34628 PyObject *swig_obj[1] ;
34629
34630 if (!args) SWIG_fail;
34631 swig_obj[0] = args;
34632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34633 if (!SWIG_IsOK(res1)) {
34634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34635 }
34636 arg1 = reinterpret_cast< wxWindow * >(argp1);
34637 {
34638 PyThreadState* __tstate = wxPyBeginAllowThreads();
34639 result = ((wxWindow const *)arg1)->GetBestSize();
34640 wxPyEndAllowThreads(__tstate);
34641 if (PyErr_Occurred()) SWIG_fail;
34642 }
34643 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34644 return resultobj;
34645 fail:
34646 return NULL;
34647 }
34648
34649
34650 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34651 PyObject *resultobj = 0;
34652 wxWindow *arg1 = (wxWindow *) 0 ;
34653 int *arg2 = (int *) 0 ;
34654 int *arg3 = (int *) 0 ;
34655 void *argp1 = 0 ;
34656 int res1 = 0 ;
34657 int temp2 ;
34658 int res2 = SWIG_TMPOBJ ;
34659 int temp3 ;
34660 int res3 = SWIG_TMPOBJ ;
34661 PyObject *swig_obj[1] ;
34662
34663 arg2 = &temp2;
34664 arg3 = &temp3;
34665 if (!args) SWIG_fail;
34666 swig_obj[0] = args;
34667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34668 if (!SWIG_IsOK(res1)) {
34669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34670 }
34671 arg1 = reinterpret_cast< wxWindow * >(argp1);
34672 {
34673 PyThreadState* __tstate = wxPyBeginAllowThreads();
34674 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34675 wxPyEndAllowThreads(__tstate);
34676 if (PyErr_Occurred()) SWIG_fail;
34677 }
34678 resultobj = SWIG_Py_Void();
34679 if (SWIG_IsTmpObj(res2)) {
34680 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34681 } else {
34682 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34683 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34684 }
34685 if (SWIG_IsTmpObj(res3)) {
34686 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34687 } else {
34688 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34689 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34690 }
34691 return resultobj;
34692 fail:
34693 return NULL;
34694 }
34695
34696
34697 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34698 PyObject *resultobj = 0;
34699 wxWindow *arg1 = (wxWindow *) 0 ;
34700 void *argp1 = 0 ;
34701 int res1 = 0 ;
34702 PyObject *swig_obj[1] ;
34703
34704 if (!args) SWIG_fail;
34705 swig_obj[0] = args;
34706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34707 if (!SWIG_IsOK(res1)) {
34708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34709 }
34710 arg1 = reinterpret_cast< wxWindow * >(argp1);
34711 {
34712 PyThreadState* __tstate = wxPyBeginAllowThreads();
34713 (arg1)->InvalidateBestSize();
34714 wxPyEndAllowThreads(__tstate);
34715 if (PyErr_Occurred()) SWIG_fail;
34716 }
34717 resultobj = SWIG_Py_Void();
34718 return resultobj;
34719 fail:
34720 return NULL;
34721 }
34722
34723
34724 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34725 PyObject *resultobj = 0;
34726 wxWindow *arg1 = (wxWindow *) 0 ;
34727 wxSize *arg2 = 0 ;
34728 void *argp1 = 0 ;
34729 int res1 = 0 ;
34730 wxSize temp2 ;
34731 PyObject * obj0 = 0 ;
34732 PyObject * obj1 = 0 ;
34733 char * kwnames[] = {
34734 (char *) "self",(char *) "size", NULL
34735 };
34736
34737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34739 if (!SWIG_IsOK(res1)) {
34740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34741 }
34742 arg1 = reinterpret_cast< wxWindow * >(argp1);
34743 {
34744 arg2 = &temp2;
34745 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34746 }
34747 {
34748 PyThreadState* __tstate = wxPyBeginAllowThreads();
34749 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34750 wxPyEndAllowThreads(__tstate);
34751 if (PyErr_Occurred()) SWIG_fail;
34752 }
34753 resultobj = SWIG_Py_Void();
34754 return resultobj;
34755 fail:
34756 return NULL;
34757 }
34758
34759
34760 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34761 PyObject *resultobj = 0;
34762 wxWindow *arg1 = (wxWindow *) 0 ;
34763 wxSize result;
34764 void *argp1 = 0 ;
34765 int res1 = 0 ;
34766 PyObject *swig_obj[1] ;
34767
34768 if (!args) SWIG_fail;
34769 swig_obj[0] = args;
34770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34771 if (!SWIG_IsOK(res1)) {
34772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34773 }
34774 arg1 = reinterpret_cast< wxWindow * >(argp1);
34775 {
34776 PyThreadState* __tstate = wxPyBeginAllowThreads();
34777 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
34778 wxPyEndAllowThreads(__tstate);
34779 if (PyErr_Occurred()) SWIG_fail;
34780 }
34781 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34782 return resultobj;
34783 fail:
34784 return NULL;
34785 }
34786
34787
34788 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34789 PyObject *resultobj = 0;
34790 wxWindow *arg1 = (wxWindow *) 0 ;
34791 int arg2 = (int) wxBOTH ;
34792 void *argp1 = 0 ;
34793 int res1 = 0 ;
34794 int val2 ;
34795 int ecode2 = 0 ;
34796 PyObject * obj0 = 0 ;
34797 PyObject * obj1 = 0 ;
34798 char * kwnames[] = {
34799 (char *) "self",(char *) "direction", NULL
34800 };
34801
34802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34804 if (!SWIG_IsOK(res1)) {
34805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34806 }
34807 arg1 = reinterpret_cast< wxWindow * >(argp1);
34808 if (obj1) {
34809 ecode2 = SWIG_AsVal_int(obj1, &val2);
34810 if (!SWIG_IsOK(ecode2)) {
34811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34812 }
34813 arg2 = static_cast< int >(val2);
34814 }
34815 {
34816 PyThreadState* __tstate = wxPyBeginAllowThreads();
34817 (arg1)->Center(arg2);
34818 wxPyEndAllowThreads(__tstate);
34819 if (PyErr_Occurred()) SWIG_fail;
34820 }
34821 resultobj = SWIG_Py_Void();
34822 return resultobj;
34823 fail:
34824 return NULL;
34825 }
34826
34827
34828 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34829 PyObject *resultobj = 0;
34830 wxWindow *arg1 = (wxWindow *) 0 ;
34831 int arg2 = (int) wxBOTH ;
34832 void *argp1 = 0 ;
34833 int res1 = 0 ;
34834 int val2 ;
34835 int ecode2 = 0 ;
34836 PyObject * obj0 = 0 ;
34837 PyObject * obj1 = 0 ;
34838 char * kwnames[] = {
34839 (char *) "self",(char *) "dir", NULL
34840 };
34841
34842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34844 if (!SWIG_IsOK(res1)) {
34845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34846 }
34847 arg1 = reinterpret_cast< wxWindow * >(argp1);
34848 if (obj1) {
34849 ecode2 = SWIG_AsVal_int(obj1, &val2);
34850 if (!SWIG_IsOK(ecode2)) {
34851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34852 }
34853 arg2 = static_cast< int >(val2);
34854 }
34855 {
34856 PyThreadState* __tstate = wxPyBeginAllowThreads();
34857 (arg1)->CenterOnParent(arg2);
34858 wxPyEndAllowThreads(__tstate);
34859 if (PyErr_Occurred()) SWIG_fail;
34860 }
34861 resultobj = SWIG_Py_Void();
34862 return resultobj;
34863 fail:
34864 return NULL;
34865 }
34866
34867
34868 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34869 PyObject *resultobj = 0;
34870 wxWindow *arg1 = (wxWindow *) 0 ;
34871 void *argp1 = 0 ;
34872 int res1 = 0 ;
34873 PyObject *swig_obj[1] ;
34874
34875 if (!args) SWIG_fail;
34876 swig_obj[0] = args;
34877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34878 if (!SWIG_IsOK(res1)) {
34879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34880 }
34881 arg1 = reinterpret_cast< wxWindow * >(argp1);
34882 {
34883 PyThreadState* __tstate = wxPyBeginAllowThreads();
34884 (arg1)->Fit();
34885 wxPyEndAllowThreads(__tstate);
34886 if (PyErr_Occurred()) SWIG_fail;
34887 }
34888 resultobj = SWIG_Py_Void();
34889 return resultobj;
34890 fail:
34891 return NULL;
34892 }
34893
34894
34895 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34896 PyObject *resultobj = 0;
34897 wxWindow *arg1 = (wxWindow *) 0 ;
34898 void *argp1 = 0 ;
34899 int res1 = 0 ;
34900 PyObject *swig_obj[1] ;
34901
34902 if (!args) SWIG_fail;
34903 swig_obj[0] = args;
34904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34905 if (!SWIG_IsOK(res1)) {
34906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34907 }
34908 arg1 = reinterpret_cast< wxWindow * >(argp1);
34909 {
34910 PyThreadState* __tstate = wxPyBeginAllowThreads();
34911 (arg1)->FitInside();
34912 wxPyEndAllowThreads(__tstate);
34913 if (PyErr_Occurred()) SWIG_fail;
34914 }
34915 resultobj = SWIG_Py_Void();
34916 return resultobj;
34917 fail:
34918 return NULL;
34919 }
34920
34921
34922 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34923 PyObject *resultobj = 0;
34924 wxWindow *arg1 = (wxWindow *) 0 ;
34925 int arg2 ;
34926 int arg3 ;
34927 int arg4 = (int) -1 ;
34928 int arg5 = (int) -1 ;
34929 int arg6 = (int) -1 ;
34930 int arg7 = (int) -1 ;
34931 void *argp1 = 0 ;
34932 int res1 = 0 ;
34933 int val2 ;
34934 int ecode2 = 0 ;
34935 int val3 ;
34936 int ecode3 = 0 ;
34937 int val4 ;
34938 int ecode4 = 0 ;
34939 int val5 ;
34940 int ecode5 = 0 ;
34941 int val6 ;
34942 int ecode6 = 0 ;
34943 int val7 ;
34944 int ecode7 = 0 ;
34945 PyObject * obj0 = 0 ;
34946 PyObject * obj1 = 0 ;
34947 PyObject * obj2 = 0 ;
34948 PyObject * obj3 = 0 ;
34949 PyObject * obj4 = 0 ;
34950 PyObject * obj5 = 0 ;
34951 PyObject * obj6 = 0 ;
34952 char * kwnames[] = {
34953 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34954 };
34955
34956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34958 if (!SWIG_IsOK(res1)) {
34959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34960 }
34961 arg1 = reinterpret_cast< wxWindow * >(argp1);
34962 ecode2 = SWIG_AsVal_int(obj1, &val2);
34963 if (!SWIG_IsOK(ecode2)) {
34964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34965 }
34966 arg2 = static_cast< int >(val2);
34967 ecode3 = SWIG_AsVal_int(obj2, &val3);
34968 if (!SWIG_IsOK(ecode3)) {
34969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34970 }
34971 arg3 = static_cast< int >(val3);
34972 if (obj3) {
34973 ecode4 = SWIG_AsVal_int(obj3, &val4);
34974 if (!SWIG_IsOK(ecode4)) {
34975 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34976 }
34977 arg4 = static_cast< int >(val4);
34978 }
34979 if (obj4) {
34980 ecode5 = SWIG_AsVal_int(obj4, &val5);
34981 if (!SWIG_IsOK(ecode5)) {
34982 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34983 }
34984 arg5 = static_cast< int >(val5);
34985 }
34986 if (obj5) {
34987 ecode6 = SWIG_AsVal_int(obj5, &val6);
34988 if (!SWIG_IsOK(ecode6)) {
34989 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34990 }
34991 arg6 = static_cast< int >(val6);
34992 }
34993 if (obj6) {
34994 ecode7 = SWIG_AsVal_int(obj6, &val7);
34995 if (!SWIG_IsOK(ecode7)) {
34996 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34997 }
34998 arg7 = static_cast< int >(val7);
34999 }
35000 {
35001 PyThreadState* __tstate = wxPyBeginAllowThreads();
35002 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
35003 wxPyEndAllowThreads(__tstate);
35004 if (PyErr_Occurred()) SWIG_fail;
35005 }
35006 resultobj = SWIG_Py_Void();
35007 return resultobj;
35008 fail:
35009 return NULL;
35010 }
35011
35012
35013 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35014 PyObject *resultobj = 0;
35015 wxWindow *arg1 = (wxWindow *) 0 ;
35016 wxSize *arg2 = 0 ;
35017 wxSize const &arg3_defvalue = wxDefaultSize ;
35018 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35019 wxSize const &arg4_defvalue = wxDefaultSize ;
35020 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
35021 void *argp1 = 0 ;
35022 int res1 = 0 ;
35023 wxSize temp2 ;
35024 wxSize temp3 ;
35025 wxSize temp4 ;
35026 PyObject * obj0 = 0 ;
35027 PyObject * obj1 = 0 ;
35028 PyObject * obj2 = 0 ;
35029 PyObject * obj3 = 0 ;
35030 char * kwnames[] = {
35031 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
35032 };
35033
35034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35036 if (!SWIG_IsOK(res1)) {
35037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35038 }
35039 arg1 = reinterpret_cast< wxWindow * >(argp1);
35040 {
35041 arg2 = &temp2;
35042 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35043 }
35044 if (obj2) {
35045 {
35046 arg3 = &temp3;
35047 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35048 }
35049 }
35050 if (obj3) {
35051 {
35052 arg4 = &temp4;
35053 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
35054 }
35055 }
35056 {
35057 PyThreadState* __tstate = wxPyBeginAllowThreads();
35058 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
35059 wxPyEndAllowThreads(__tstate);
35060 if (PyErr_Occurred()) SWIG_fail;
35061 }
35062 resultobj = SWIG_Py_Void();
35063 return resultobj;
35064 fail:
35065 return NULL;
35066 }
35067
35068
35069 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35070 PyObject *resultobj = 0;
35071 wxWindow *arg1 = (wxWindow *) 0 ;
35072 int arg2 ;
35073 int arg3 ;
35074 int arg4 = (int) -1 ;
35075 int arg5 = (int) -1 ;
35076 void *argp1 = 0 ;
35077 int res1 = 0 ;
35078 int val2 ;
35079 int ecode2 = 0 ;
35080 int val3 ;
35081 int ecode3 = 0 ;
35082 int val4 ;
35083 int ecode4 = 0 ;
35084 int val5 ;
35085 int ecode5 = 0 ;
35086 PyObject * obj0 = 0 ;
35087 PyObject * obj1 = 0 ;
35088 PyObject * obj2 = 0 ;
35089 PyObject * obj3 = 0 ;
35090 PyObject * obj4 = 0 ;
35091 char * kwnames[] = {
35092 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
35093 };
35094
35095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35097 if (!SWIG_IsOK(res1)) {
35098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
35099 }
35100 arg1 = reinterpret_cast< wxWindow * >(argp1);
35101 ecode2 = SWIG_AsVal_int(obj1, &val2);
35102 if (!SWIG_IsOK(ecode2)) {
35103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
35104 }
35105 arg2 = static_cast< int >(val2);
35106 ecode3 = SWIG_AsVal_int(obj2, &val3);
35107 if (!SWIG_IsOK(ecode3)) {
35108 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
35109 }
35110 arg3 = static_cast< int >(val3);
35111 if (obj3) {
35112 ecode4 = SWIG_AsVal_int(obj3, &val4);
35113 if (!SWIG_IsOK(ecode4)) {
35114 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
35115 }
35116 arg4 = static_cast< int >(val4);
35117 }
35118 if (obj4) {
35119 ecode5 = SWIG_AsVal_int(obj4, &val5);
35120 if (!SWIG_IsOK(ecode5)) {
35121 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
35122 }
35123 arg5 = static_cast< int >(val5);
35124 }
35125 {
35126 PyThreadState* __tstate = wxPyBeginAllowThreads();
35127 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
35128 wxPyEndAllowThreads(__tstate);
35129 if (PyErr_Occurred()) SWIG_fail;
35130 }
35131 resultobj = SWIG_Py_Void();
35132 return resultobj;
35133 fail:
35134 return NULL;
35135 }
35136
35137
35138 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35139 PyObject *resultobj = 0;
35140 wxWindow *arg1 = (wxWindow *) 0 ;
35141 wxSize *arg2 = 0 ;
35142 wxSize const &arg3_defvalue = wxDefaultSize ;
35143 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35144 void *argp1 = 0 ;
35145 int res1 = 0 ;
35146 wxSize temp2 ;
35147 wxSize temp3 ;
35148 PyObject * obj0 = 0 ;
35149 PyObject * obj1 = 0 ;
35150 PyObject * obj2 = 0 ;
35151 char * kwnames[] = {
35152 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
35153 };
35154
35155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35157 if (!SWIG_IsOK(res1)) {
35158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35159 }
35160 arg1 = reinterpret_cast< wxWindow * >(argp1);
35161 {
35162 arg2 = &temp2;
35163 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35164 }
35165 if (obj2) {
35166 {
35167 arg3 = &temp3;
35168 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35169 }
35170 }
35171 {
35172 PyThreadState* __tstate = wxPyBeginAllowThreads();
35173 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35174 wxPyEndAllowThreads(__tstate);
35175 if (PyErr_Occurred()) SWIG_fail;
35176 }
35177 resultobj = SWIG_Py_Void();
35178 return resultobj;
35179 fail:
35180 return NULL;
35181 }
35182
35183
35184 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35185 PyObject *resultobj = 0;
35186 wxWindow *arg1 = (wxWindow *) 0 ;
35187 wxSize result;
35188 void *argp1 = 0 ;
35189 int res1 = 0 ;
35190 PyObject *swig_obj[1] ;
35191
35192 if (!args) SWIG_fail;
35193 swig_obj[0] = args;
35194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35195 if (!SWIG_IsOK(res1)) {
35196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35197 }
35198 arg1 = reinterpret_cast< wxWindow * >(argp1);
35199 {
35200 PyThreadState* __tstate = wxPyBeginAllowThreads();
35201 result = ((wxWindow const *)arg1)->GetMaxSize();
35202 wxPyEndAllowThreads(__tstate);
35203 if (PyErr_Occurred()) SWIG_fail;
35204 }
35205 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35206 return resultobj;
35207 fail:
35208 return NULL;
35209 }
35210
35211
35212 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35213 PyObject *resultobj = 0;
35214 wxWindow *arg1 = (wxWindow *) 0 ;
35215 wxSize result;
35216 void *argp1 = 0 ;
35217 int res1 = 0 ;
35218 PyObject *swig_obj[1] ;
35219
35220 if (!args) SWIG_fail;
35221 swig_obj[0] = args;
35222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35223 if (!SWIG_IsOK(res1)) {
35224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35225 }
35226 arg1 = reinterpret_cast< wxWindow * >(argp1);
35227 {
35228 PyThreadState* __tstate = wxPyBeginAllowThreads();
35229 result = ((wxWindow const *)arg1)->GetMinSize();
35230 wxPyEndAllowThreads(__tstate);
35231 if (PyErr_Occurred()) SWIG_fail;
35232 }
35233 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35234 return resultobj;
35235 fail:
35236 return NULL;
35237 }
35238
35239
35240 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35241 PyObject *resultobj = 0;
35242 wxWindow *arg1 = (wxWindow *) 0 ;
35243 wxSize *arg2 = 0 ;
35244 void *argp1 = 0 ;
35245 int res1 = 0 ;
35246 wxSize temp2 ;
35247 PyObject * obj0 = 0 ;
35248 PyObject * obj1 = 0 ;
35249 char * kwnames[] = {
35250 (char *) "self",(char *) "minSize", NULL
35251 };
35252
35253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35255 if (!SWIG_IsOK(res1)) {
35256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35257 }
35258 arg1 = reinterpret_cast< wxWindow * >(argp1);
35259 {
35260 arg2 = &temp2;
35261 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35262 }
35263 {
35264 PyThreadState* __tstate = wxPyBeginAllowThreads();
35265 (arg1)->SetMinSize((wxSize const &)*arg2);
35266 wxPyEndAllowThreads(__tstate);
35267 if (PyErr_Occurred()) SWIG_fail;
35268 }
35269 resultobj = SWIG_Py_Void();
35270 return resultobj;
35271 fail:
35272 return NULL;
35273 }
35274
35275
35276 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35277 PyObject *resultobj = 0;
35278 wxWindow *arg1 = (wxWindow *) 0 ;
35279 wxSize *arg2 = 0 ;
35280 void *argp1 = 0 ;
35281 int res1 = 0 ;
35282 wxSize temp2 ;
35283 PyObject * obj0 = 0 ;
35284 PyObject * obj1 = 0 ;
35285 char * kwnames[] = {
35286 (char *) "self",(char *) "maxSize", NULL
35287 };
35288
35289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35291 if (!SWIG_IsOK(res1)) {
35292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35293 }
35294 arg1 = reinterpret_cast< wxWindow * >(argp1);
35295 {
35296 arg2 = &temp2;
35297 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35298 }
35299 {
35300 PyThreadState* __tstate = wxPyBeginAllowThreads();
35301 (arg1)->SetMaxSize((wxSize const &)*arg2);
35302 wxPyEndAllowThreads(__tstate);
35303 if (PyErr_Occurred()) SWIG_fail;
35304 }
35305 resultobj = SWIG_Py_Void();
35306 return resultobj;
35307 fail:
35308 return NULL;
35309 }
35310
35311
35312 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35313 PyObject *resultobj = 0;
35314 wxWindow *arg1 = (wxWindow *) 0 ;
35315 int result;
35316 void *argp1 = 0 ;
35317 int res1 = 0 ;
35318 PyObject *swig_obj[1] ;
35319
35320 if (!args) SWIG_fail;
35321 swig_obj[0] = args;
35322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35323 if (!SWIG_IsOK(res1)) {
35324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35325 }
35326 arg1 = reinterpret_cast< wxWindow * >(argp1);
35327 {
35328 PyThreadState* __tstate = wxPyBeginAllowThreads();
35329 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35330 wxPyEndAllowThreads(__tstate);
35331 if (PyErr_Occurred()) SWIG_fail;
35332 }
35333 resultobj = SWIG_From_int(static_cast< int >(result));
35334 return resultobj;
35335 fail:
35336 return NULL;
35337 }
35338
35339
35340 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35341 PyObject *resultobj = 0;
35342 wxWindow *arg1 = (wxWindow *) 0 ;
35343 int result;
35344 void *argp1 = 0 ;
35345 int res1 = 0 ;
35346 PyObject *swig_obj[1] ;
35347
35348 if (!args) SWIG_fail;
35349 swig_obj[0] = args;
35350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35351 if (!SWIG_IsOK(res1)) {
35352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35353 }
35354 arg1 = reinterpret_cast< wxWindow * >(argp1);
35355 {
35356 PyThreadState* __tstate = wxPyBeginAllowThreads();
35357 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35358 wxPyEndAllowThreads(__tstate);
35359 if (PyErr_Occurred()) SWIG_fail;
35360 }
35361 resultobj = SWIG_From_int(static_cast< int >(result));
35362 return resultobj;
35363 fail:
35364 return NULL;
35365 }
35366
35367
35368 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35369 PyObject *resultobj = 0;
35370 wxWindow *arg1 = (wxWindow *) 0 ;
35371 int result;
35372 void *argp1 = 0 ;
35373 int res1 = 0 ;
35374 PyObject *swig_obj[1] ;
35375
35376 if (!args) SWIG_fail;
35377 swig_obj[0] = args;
35378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35379 if (!SWIG_IsOK(res1)) {
35380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35381 }
35382 arg1 = reinterpret_cast< wxWindow * >(argp1);
35383 {
35384 PyThreadState* __tstate = wxPyBeginAllowThreads();
35385 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35386 wxPyEndAllowThreads(__tstate);
35387 if (PyErr_Occurred()) SWIG_fail;
35388 }
35389 resultobj = SWIG_From_int(static_cast< int >(result));
35390 return resultobj;
35391 fail:
35392 return NULL;
35393 }
35394
35395
35396 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35397 PyObject *resultobj = 0;
35398 wxWindow *arg1 = (wxWindow *) 0 ;
35399 int result;
35400 void *argp1 = 0 ;
35401 int res1 = 0 ;
35402 PyObject *swig_obj[1] ;
35403
35404 if (!args) SWIG_fail;
35405 swig_obj[0] = args;
35406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35407 if (!SWIG_IsOK(res1)) {
35408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35409 }
35410 arg1 = reinterpret_cast< wxWindow * >(argp1);
35411 {
35412 PyThreadState* __tstate = wxPyBeginAllowThreads();
35413 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35414 wxPyEndAllowThreads(__tstate);
35415 if (PyErr_Occurred()) SWIG_fail;
35416 }
35417 resultobj = SWIG_From_int(static_cast< int >(result));
35418 return resultobj;
35419 fail:
35420 return NULL;
35421 }
35422
35423
35424 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35425 PyObject *resultobj = 0;
35426 wxWindow *arg1 = (wxWindow *) 0 ;
35427 wxSize *arg2 = 0 ;
35428 void *argp1 = 0 ;
35429 int res1 = 0 ;
35430 wxSize temp2 ;
35431 PyObject * obj0 = 0 ;
35432 PyObject * obj1 = 0 ;
35433 char * kwnames[] = {
35434 (char *) "self",(char *) "size", NULL
35435 };
35436
35437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35439 if (!SWIG_IsOK(res1)) {
35440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35441 }
35442 arg1 = reinterpret_cast< wxWindow * >(argp1);
35443 {
35444 arg2 = &temp2;
35445 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35446 }
35447 {
35448 PyThreadState* __tstate = wxPyBeginAllowThreads();
35449 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35450 wxPyEndAllowThreads(__tstate);
35451 if (PyErr_Occurred()) SWIG_fail;
35452 }
35453 resultobj = SWIG_Py_Void();
35454 return resultobj;
35455 fail:
35456 return NULL;
35457 }
35458
35459
35460 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35461 PyObject *resultobj = 0;
35462 wxWindow *arg1 = (wxWindow *) 0 ;
35463 int arg2 ;
35464 int arg3 ;
35465 void *argp1 = 0 ;
35466 int res1 = 0 ;
35467 int val2 ;
35468 int ecode2 = 0 ;
35469 int val3 ;
35470 int ecode3 = 0 ;
35471 PyObject * obj0 = 0 ;
35472 PyObject * obj1 = 0 ;
35473 PyObject * obj2 = 0 ;
35474 char * kwnames[] = {
35475 (char *) "self",(char *) "w",(char *) "h", NULL
35476 };
35477
35478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35480 if (!SWIG_IsOK(res1)) {
35481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35482 }
35483 arg1 = reinterpret_cast< wxWindow * >(argp1);
35484 ecode2 = SWIG_AsVal_int(obj1, &val2);
35485 if (!SWIG_IsOK(ecode2)) {
35486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35487 }
35488 arg2 = static_cast< int >(val2);
35489 ecode3 = SWIG_AsVal_int(obj2, &val3);
35490 if (!SWIG_IsOK(ecode3)) {
35491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35492 }
35493 arg3 = static_cast< int >(val3);
35494 {
35495 PyThreadState* __tstate = wxPyBeginAllowThreads();
35496 (arg1)->SetVirtualSize(arg2,arg3);
35497 wxPyEndAllowThreads(__tstate);
35498 if (PyErr_Occurred()) SWIG_fail;
35499 }
35500 resultobj = SWIG_Py_Void();
35501 return resultobj;
35502 fail:
35503 return NULL;
35504 }
35505
35506
35507 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35508 PyObject *resultobj = 0;
35509 wxWindow *arg1 = (wxWindow *) 0 ;
35510 wxSize result;
35511 void *argp1 = 0 ;
35512 int res1 = 0 ;
35513 PyObject *swig_obj[1] ;
35514
35515 if (!args) SWIG_fail;
35516 swig_obj[0] = args;
35517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35518 if (!SWIG_IsOK(res1)) {
35519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35520 }
35521 arg1 = reinterpret_cast< wxWindow * >(argp1);
35522 {
35523 PyThreadState* __tstate = wxPyBeginAllowThreads();
35524 result = ((wxWindow const *)arg1)->GetVirtualSize();
35525 wxPyEndAllowThreads(__tstate);
35526 if (PyErr_Occurred()) SWIG_fail;
35527 }
35528 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35529 return resultobj;
35530 fail:
35531 return NULL;
35532 }
35533
35534
35535 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35536 PyObject *resultobj = 0;
35537 wxWindow *arg1 = (wxWindow *) 0 ;
35538 int *arg2 = (int *) 0 ;
35539 int *arg3 = (int *) 0 ;
35540 void *argp1 = 0 ;
35541 int res1 = 0 ;
35542 int temp2 ;
35543 int res2 = SWIG_TMPOBJ ;
35544 int temp3 ;
35545 int res3 = SWIG_TMPOBJ ;
35546 PyObject *swig_obj[1] ;
35547
35548 arg2 = &temp2;
35549 arg3 = &temp3;
35550 if (!args) SWIG_fail;
35551 swig_obj[0] = args;
35552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35553 if (!SWIG_IsOK(res1)) {
35554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35555 }
35556 arg1 = reinterpret_cast< wxWindow * >(argp1);
35557 {
35558 PyThreadState* __tstate = wxPyBeginAllowThreads();
35559 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35560 wxPyEndAllowThreads(__tstate);
35561 if (PyErr_Occurred()) SWIG_fail;
35562 }
35563 resultobj = SWIG_Py_Void();
35564 if (SWIG_IsTmpObj(res2)) {
35565 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35566 } else {
35567 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35568 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35569 }
35570 if (SWIG_IsTmpObj(res3)) {
35571 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35572 } else {
35573 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35574 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35575 }
35576 return resultobj;
35577 fail:
35578 return NULL;
35579 }
35580
35581
35582 SWIGINTERN PyObject *_wrap_Window_GetWindowBorderSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35583 PyObject *resultobj = 0;
35584 wxWindow *arg1 = (wxWindow *) 0 ;
35585 wxSize result;
35586 void *argp1 = 0 ;
35587 int res1 = 0 ;
35588 PyObject *swig_obj[1] ;
35589
35590 if (!args) SWIG_fail;
35591 swig_obj[0] = args;
35592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35593 if (!SWIG_IsOK(res1)) {
35594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowBorderSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35595 }
35596 arg1 = reinterpret_cast< wxWindow * >(argp1);
35597 {
35598 PyThreadState* __tstate = wxPyBeginAllowThreads();
35599 result = ((wxWindow const *)arg1)->GetWindowBorderSize();
35600 wxPyEndAllowThreads(__tstate);
35601 if (PyErr_Occurred()) SWIG_fail;
35602 }
35603 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35604 return resultobj;
35605 fail:
35606 return NULL;
35607 }
35608
35609
35610 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35611 PyObject *resultobj = 0;
35612 wxWindow *arg1 = (wxWindow *) 0 ;
35613 wxSize result;
35614 void *argp1 = 0 ;
35615 int res1 = 0 ;
35616 PyObject *swig_obj[1] ;
35617
35618 if (!args) SWIG_fail;
35619 swig_obj[0] = args;
35620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35621 if (!SWIG_IsOK(res1)) {
35622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35623 }
35624 arg1 = reinterpret_cast< wxWindow * >(argp1);
35625 {
35626 PyThreadState* __tstate = wxPyBeginAllowThreads();
35627 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35628 wxPyEndAllowThreads(__tstate);
35629 if (PyErr_Occurred()) SWIG_fail;
35630 }
35631 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35632 return resultobj;
35633 fail:
35634 return NULL;
35635 }
35636
35637
35638 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35639 PyObject *resultobj = 0;
35640 wxWindow *arg1 = (wxWindow *) 0 ;
35641 bool arg2 = (bool) true ;
35642 bool result;
35643 void *argp1 = 0 ;
35644 int res1 = 0 ;
35645 bool val2 ;
35646 int ecode2 = 0 ;
35647 PyObject * obj0 = 0 ;
35648 PyObject * obj1 = 0 ;
35649 char * kwnames[] = {
35650 (char *) "self",(char *) "show", NULL
35651 };
35652
35653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35655 if (!SWIG_IsOK(res1)) {
35656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35657 }
35658 arg1 = reinterpret_cast< wxWindow * >(argp1);
35659 if (obj1) {
35660 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35661 if (!SWIG_IsOK(ecode2)) {
35662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35663 }
35664 arg2 = static_cast< bool >(val2);
35665 }
35666 {
35667 PyThreadState* __tstate = wxPyBeginAllowThreads();
35668 result = (bool)(arg1)->Show(arg2);
35669 wxPyEndAllowThreads(__tstate);
35670 if (PyErr_Occurred()) SWIG_fail;
35671 }
35672 {
35673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35674 }
35675 return resultobj;
35676 fail:
35677 return NULL;
35678 }
35679
35680
35681 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35682 PyObject *resultobj = 0;
35683 wxWindow *arg1 = (wxWindow *) 0 ;
35684 bool result;
35685 void *argp1 = 0 ;
35686 int res1 = 0 ;
35687 PyObject *swig_obj[1] ;
35688
35689 if (!args) SWIG_fail;
35690 swig_obj[0] = args;
35691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35692 if (!SWIG_IsOK(res1)) {
35693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35694 }
35695 arg1 = reinterpret_cast< wxWindow * >(argp1);
35696 {
35697 PyThreadState* __tstate = wxPyBeginAllowThreads();
35698 result = (bool)(arg1)->Hide();
35699 wxPyEndAllowThreads(__tstate);
35700 if (PyErr_Occurred()) SWIG_fail;
35701 }
35702 {
35703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35704 }
35705 return resultobj;
35706 fail:
35707 return NULL;
35708 }
35709
35710
35711 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35712 PyObject *resultobj = 0;
35713 wxWindow *arg1 = (wxWindow *) 0 ;
35714 bool arg2 = (bool) true ;
35715 bool result;
35716 void *argp1 = 0 ;
35717 int res1 = 0 ;
35718 bool val2 ;
35719 int ecode2 = 0 ;
35720 PyObject * obj0 = 0 ;
35721 PyObject * obj1 = 0 ;
35722 char * kwnames[] = {
35723 (char *) "self",(char *) "enable", NULL
35724 };
35725
35726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35728 if (!SWIG_IsOK(res1)) {
35729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35730 }
35731 arg1 = reinterpret_cast< wxWindow * >(argp1);
35732 if (obj1) {
35733 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35734 if (!SWIG_IsOK(ecode2)) {
35735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35736 }
35737 arg2 = static_cast< bool >(val2);
35738 }
35739 {
35740 PyThreadState* __tstate = wxPyBeginAllowThreads();
35741 result = (bool)(arg1)->Enable(arg2);
35742 wxPyEndAllowThreads(__tstate);
35743 if (PyErr_Occurred()) SWIG_fail;
35744 }
35745 {
35746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35747 }
35748 return resultobj;
35749 fail:
35750 return NULL;
35751 }
35752
35753
35754 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35755 PyObject *resultobj = 0;
35756 wxWindow *arg1 = (wxWindow *) 0 ;
35757 bool result;
35758 void *argp1 = 0 ;
35759 int res1 = 0 ;
35760 PyObject *swig_obj[1] ;
35761
35762 if (!args) SWIG_fail;
35763 swig_obj[0] = args;
35764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35765 if (!SWIG_IsOK(res1)) {
35766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35767 }
35768 arg1 = reinterpret_cast< wxWindow * >(argp1);
35769 {
35770 PyThreadState* __tstate = wxPyBeginAllowThreads();
35771 result = (bool)(arg1)->Disable();
35772 wxPyEndAllowThreads(__tstate);
35773 if (PyErr_Occurred()) SWIG_fail;
35774 }
35775 {
35776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35777 }
35778 return resultobj;
35779 fail:
35780 return NULL;
35781 }
35782
35783
35784 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35785 PyObject *resultobj = 0;
35786 wxWindow *arg1 = (wxWindow *) 0 ;
35787 bool result;
35788 void *argp1 = 0 ;
35789 int res1 = 0 ;
35790 PyObject *swig_obj[1] ;
35791
35792 if (!args) SWIG_fail;
35793 swig_obj[0] = args;
35794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35795 if (!SWIG_IsOK(res1)) {
35796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35797 }
35798 arg1 = reinterpret_cast< wxWindow * >(argp1);
35799 {
35800 PyThreadState* __tstate = wxPyBeginAllowThreads();
35801 result = (bool)((wxWindow const *)arg1)->IsShown();
35802 wxPyEndAllowThreads(__tstate);
35803 if (PyErr_Occurred()) SWIG_fail;
35804 }
35805 {
35806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35807 }
35808 return resultobj;
35809 fail:
35810 return NULL;
35811 }
35812
35813
35814 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35815 PyObject *resultobj = 0;
35816 wxWindow *arg1 = (wxWindow *) 0 ;
35817 bool result;
35818 void *argp1 = 0 ;
35819 int res1 = 0 ;
35820 PyObject *swig_obj[1] ;
35821
35822 if (!args) SWIG_fail;
35823 swig_obj[0] = args;
35824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35825 if (!SWIG_IsOK(res1)) {
35826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35827 }
35828 arg1 = reinterpret_cast< wxWindow * >(argp1);
35829 {
35830 PyThreadState* __tstate = wxPyBeginAllowThreads();
35831 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35832 wxPyEndAllowThreads(__tstate);
35833 if (PyErr_Occurred()) SWIG_fail;
35834 }
35835 {
35836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35837 }
35838 return resultobj;
35839 fail:
35840 return NULL;
35841 }
35842
35843
35844 SWIGINTERN PyObject *_wrap_Window_IsThisEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35845 PyObject *resultobj = 0;
35846 wxWindow *arg1 = (wxWindow *) 0 ;
35847 bool result;
35848 void *argp1 = 0 ;
35849 int res1 = 0 ;
35850 PyObject *swig_obj[1] ;
35851
35852 if (!args) SWIG_fail;
35853 swig_obj[0] = args;
35854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35855 if (!SWIG_IsOK(res1)) {
35856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsThisEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35857 }
35858 arg1 = reinterpret_cast< wxWindow * >(argp1);
35859 {
35860 PyThreadState* __tstate = wxPyBeginAllowThreads();
35861 result = (bool)((wxWindow const *)arg1)->IsThisEnabled();
35862 wxPyEndAllowThreads(__tstate);
35863 if (PyErr_Occurred()) SWIG_fail;
35864 }
35865 {
35866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35867 }
35868 return resultobj;
35869 fail:
35870 return NULL;
35871 }
35872
35873
35874 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35875 PyObject *resultobj = 0;
35876 wxWindow *arg1 = (wxWindow *) 0 ;
35877 bool result;
35878 void *argp1 = 0 ;
35879 int res1 = 0 ;
35880 PyObject *swig_obj[1] ;
35881
35882 if (!args) SWIG_fail;
35883 swig_obj[0] = args;
35884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35885 if (!SWIG_IsOK(res1)) {
35886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35887 }
35888 arg1 = reinterpret_cast< wxWindow * >(argp1);
35889 {
35890 PyThreadState* __tstate = wxPyBeginAllowThreads();
35891 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35892 wxPyEndAllowThreads(__tstate);
35893 if (PyErr_Occurred()) SWIG_fail;
35894 }
35895 {
35896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35897 }
35898 return resultobj;
35899 fail:
35900 return NULL;
35901 }
35902
35903
35904 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35905 PyObject *resultobj = 0;
35906 wxWindow *arg1 = (wxWindow *) 0 ;
35907 long arg2 ;
35908 void *argp1 = 0 ;
35909 int res1 = 0 ;
35910 long val2 ;
35911 int ecode2 = 0 ;
35912 PyObject * obj0 = 0 ;
35913 PyObject * obj1 = 0 ;
35914 char * kwnames[] = {
35915 (char *) "self",(char *) "style", NULL
35916 };
35917
35918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35920 if (!SWIG_IsOK(res1)) {
35921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35922 }
35923 arg1 = reinterpret_cast< wxWindow * >(argp1);
35924 ecode2 = SWIG_AsVal_long(obj1, &val2);
35925 if (!SWIG_IsOK(ecode2)) {
35926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35927 }
35928 arg2 = static_cast< long >(val2);
35929 {
35930 PyThreadState* __tstate = wxPyBeginAllowThreads();
35931 (arg1)->SetWindowStyleFlag(arg2);
35932 wxPyEndAllowThreads(__tstate);
35933 if (PyErr_Occurred()) SWIG_fail;
35934 }
35935 resultobj = SWIG_Py_Void();
35936 return resultobj;
35937 fail:
35938 return NULL;
35939 }
35940
35941
35942 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35943 PyObject *resultobj = 0;
35944 wxWindow *arg1 = (wxWindow *) 0 ;
35945 long result;
35946 void *argp1 = 0 ;
35947 int res1 = 0 ;
35948 PyObject *swig_obj[1] ;
35949
35950 if (!args) SWIG_fail;
35951 swig_obj[0] = args;
35952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35953 if (!SWIG_IsOK(res1)) {
35954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35955 }
35956 arg1 = reinterpret_cast< wxWindow * >(argp1);
35957 {
35958 PyThreadState* __tstate = wxPyBeginAllowThreads();
35959 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35960 wxPyEndAllowThreads(__tstate);
35961 if (PyErr_Occurred()) SWIG_fail;
35962 }
35963 resultobj = SWIG_From_long(static_cast< long >(result));
35964 return resultobj;
35965 fail:
35966 return NULL;
35967 }
35968
35969
35970 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35971 PyObject *resultobj = 0;
35972 wxWindow *arg1 = (wxWindow *) 0 ;
35973 int arg2 ;
35974 bool result;
35975 void *argp1 = 0 ;
35976 int res1 = 0 ;
35977 int val2 ;
35978 int ecode2 = 0 ;
35979 PyObject * obj0 = 0 ;
35980 PyObject * obj1 = 0 ;
35981 char * kwnames[] = {
35982 (char *) "self",(char *) "flag", NULL
35983 };
35984
35985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35987 if (!SWIG_IsOK(res1)) {
35988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35989 }
35990 arg1 = reinterpret_cast< wxWindow * >(argp1);
35991 ecode2 = SWIG_AsVal_int(obj1, &val2);
35992 if (!SWIG_IsOK(ecode2)) {
35993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35994 }
35995 arg2 = static_cast< int >(val2);
35996 {
35997 PyThreadState* __tstate = wxPyBeginAllowThreads();
35998 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35999 wxPyEndAllowThreads(__tstate);
36000 if (PyErr_Occurred()) SWIG_fail;
36001 }
36002 {
36003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36004 }
36005 return resultobj;
36006 fail:
36007 return NULL;
36008 }
36009
36010
36011 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36012 PyObject *resultobj = 0;
36013 wxWindow *arg1 = (wxWindow *) 0 ;
36014 bool result;
36015 void *argp1 = 0 ;
36016 int res1 = 0 ;
36017 PyObject *swig_obj[1] ;
36018
36019 if (!args) SWIG_fail;
36020 swig_obj[0] = args;
36021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36022 if (!SWIG_IsOK(res1)) {
36023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
36024 }
36025 arg1 = reinterpret_cast< wxWindow * >(argp1);
36026 {
36027 PyThreadState* __tstate = wxPyBeginAllowThreads();
36028 result = (bool)((wxWindow const *)arg1)->IsRetained();
36029 wxPyEndAllowThreads(__tstate);
36030 if (PyErr_Occurred()) SWIG_fail;
36031 }
36032 {
36033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36034 }
36035 return resultobj;
36036 fail:
36037 return NULL;
36038 }
36039
36040
36041 SWIGINTERN PyObject *_wrap_Window_ToggleWindowStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36042 PyObject *resultobj = 0;
36043 wxWindow *arg1 = (wxWindow *) 0 ;
36044 int arg2 ;
36045 bool result;
36046 void *argp1 = 0 ;
36047 int res1 = 0 ;
36048 int val2 ;
36049 int ecode2 = 0 ;
36050 PyObject * obj0 = 0 ;
36051 PyObject * obj1 = 0 ;
36052 char * kwnames[] = {
36053 (char *) "self",(char *) "flag", NULL
36054 };
36055
36056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ToggleWindowStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36058 if (!SWIG_IsOK(res1)) {
36059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ToggleWindowStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36060 }
36061 arg1 = reinterpret_cast< wxWindow * >(argp1);
36062 ecode2 = SWIG_AsVal_int(obj1, &val2);
36063 if (!SWIG_IsOK(ecode2)) {
36064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ToggleWindowStyle" "', expected argument " "2"" of type '" "int""'");
36065 }
36066 arg2 = static_cast< int >(val2);
36067 {
36068 PyThreadState* __tstate = wxPyBeginAllowThreads();
36069 result = (bool)(arg1)->ToggleWindowStyle(arg2);
36070 wxPyEndAllowThreads(__tstate);
36071 if (PyErr_Occurred()) SWIG_fail;
36072 }
36073 {
36074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36075 }
36076 return resultobj;
36077 fail:
36078 return NULL;
36079 }
36080
36081
36082 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36083 PyObject *resultobj = 0;
36084 wxWindow *arg1 = (wxWindow *) 0 ;
36085 long arg2 ;
36086 void *argp1 = 0 ;
36087 int res1 = 0 ;
36088 long val2 ;
36089 int ecode2 = 0 ;
36090 PyObject * obj0 = 0 ;
36091 PyObject * obj1 = 0 ;
36092 char * kwnames[] = {
36093 (char *) "self",(char *) "exStyle", NULL
36094 };
36095
36096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36098 if (!SWIG_IsOK(res1)) {
36099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36100 }
36101 arg1 = reinterpret_cast< wxWindow * >(argp1);
36102 ecode2 = SWIG_AsVal_long(obj1, &val2);
36103 if (!SWIG_IsOK(ecode2)) {
36104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
36105 }
36106 arg2 = static_cast< long >(val2);
36107 {
36108 PyThreadState* __tstate = wxPyBeginAllowThreads();
36109 (arg1)->SetExtraStyle(arg2);
36110 wxPyEndAllowThreads(__tstate);
36111 if (PyErr_Occurred()) SWIG_fail;
36112 }
36113 resultobj = SWIG_Py_Void();
36114 return resultobj;
36115 fail:
36116 return NULL;
36117 }
36118
36119
36120 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36121 PyObject *resultobj = 0;
36122 wxWindow *arg1 = (wxWindow *) 0 ;
36123 long result;
36124 void *argp1 = 0 ;
36125 int res1 = 0 ;
36126 PyObject *swig_obj[1] ;
36127
36128 if (!args) SWIG_fail;
36129 swig_obj[0] = args;
36130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36131 if (!SWIG_IsOK(res1)) {
36132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36133 }
36134 arg1 = reinterpret_cast< wxWindow * >(argp1);
36135 {
36136 PyThreadState* __tstate = wxPyBeginAllowThreads();
36137 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
36138 wxPyEndAllowThreads(__tstate);
36139 if (PyErr_Occurred()) SWIG_fail;
36140 }
36141 resultobj = SWIG_From_long(static_cast< long >(result));
36142 return resultobj;
36143 fail:
36144 return NULL;
36145 }
36146
36147
36148 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36149 PyObject *resultobj = 0;
36150 wxWindow *arg1 = (wxWindow *) 0 ;
36151 bool arg2 = (bool) true ;
36152 void *argp1 = 0 ;
36153 int res1 = 0 ;
36154 bool val2 ;
36155 int ecode2 = 0 ;
36156 PyObject * obj0 = 0 ;
36157 PyObject * obj1 = 0 ;
36158 char * kwnames[] = {
36159 (char *) "self",(char *) "modal", NULL
36160 };
36161
36162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
36163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36164 if (!SWIG_IsOK(res1)) {
36165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
36166 }
36167 arg1 = reinterpret_cast< wxWindow * >(argp1);
36168 if (obj1) {
36169 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36170 if (!SWIG_IsOK(ecode2)) {
36171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
36172 }
36173 arg2 = static_cast< bool >(val2);
36174 }
36175 {
36176 PyThreadState* __tstate = wxPyBeginAllowThreads();
36177 (arg1)->MakeModal(arg2);
36178 wxPyEndAllowThreads(__tstate);
36179 if (PyErr_Occurred()) SWIG_fail;
36180 }
36181 resultobj = SWIG_Py_Void();
36182 return resultobj;
36183 fail:
36184 return NULL;
36185 }
36186
36187
36188 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36189 PyObject *resultobj = 0;
36190 wxWindow *arg1 = (wxWindow *) 0 ;
36191 bool arg2 ;
36192 void *argp1 = 0 ;
36193 int res1 = 0 ;
36194 bool val2 ;
36195 int ecode2 = 0 ;
36196 PyObject * obj0 = 0 ;
36197 PyObject * obj1 = 0 ;
36198 char * kwnames[] = {
36199 (char *) "self",(char *) "enableTheme", NULL
36200 };
36201
36202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
36203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36204 if (!SWIG_IsOK(res1)) {
36205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
36206 }
36207 arg1 = reinterpret_cast< wxWindow * >(argp1);
36208 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36209 if (!SWIG_IsOK(ecode2)) {
36210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36211 }
36212 arg2 = static_cast< bool >(val2);
36213 {
36214 PyThreadState* __tstate = wxPyBeginAllowThreads();
36215 (arg1)->SetThemeEnabled(arg2);
36216 wxPyEndAllowThreads(__tstate);
36217 if (PyErr_Occurred()) SWIG_fail;
36218 }
36219 resultobj = SWIG_Py_Void();
36220 return resultobj;
36221 fail:
36222 return NULL;
36223 }
36224
36225
36226 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36227 PyObject *resultobj = 0;
36228 wxWindow *arg1 = (wxWindow *) 0 ;
36229 bool result;
36230 void *argp1 = 0 ;
36231 int res1 = 0 ;
36232 PyObject *swig_obj[1] ;
36233
36234 if (!args) SWIG_fail;
36235 swig_obj[0] = args;
36236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36237 if (!SWIG_IsOK(res1)) {
36238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36239 }
36240 arg1 = reinterpret_cast< wxWindow * >(argp1);
36241 {
36242 PyThreadState* __tstate = wxPyBeginAllowThreads();
36243 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36244 wxPyEndAllowThreads(__tstate);
36245 if (PyErr_Occurred()) SWIG_fail;
36246 }
36247 {
36248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36249 }
36250 return resultobj;
36251 fail:
36252 return NULL;
36253 }
36254
36255
36256 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36257 PyObject *resultobj = 0;
36258 wxWindow *arg1 = (wxWindow *) 0 ;
36259 void *argp1 = 0 ;
36260 int res1 = 0 ;
36261 PyObject *swig_obj[1] ;
36262
36263 if (!args) SWIG_fail;
36264 swig_obj[0] = args;
36265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36266 if (!SWIG_IsOK(res1)) {
36267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36268 }
36269 arg1 = reinterpret_cast< wxWindow * >(argp1);
36270 {
36271 PyThreadState* __tstate = wxPyBeginAllowThreads();
36272 (arg1)->SetFocus();
36273 wxPyEndAllowThreads(__tstate);
36274 if (PyErr_Occurred()) SWIG_fail;
36275 }
36276 resultobj = SWIG_Py_Void();
36277 return resultobj;
36278 fail:
36279 return NULL;
36280 }
36281
36282
36283 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36284 PyObject *resultobj = 0;
36285 wxWindow *arg1 = (wxWindow *) 0 ;
36286 void *argp1 = 0 ;
36287 int res1 = 0 ;
36288 PyObject *swig_obj[1] ;
36289
36290 if (!args) SWIG_fail;
36291 swig_obj[0] = args;
36292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36293 if (!SWIG_IsOK(res1)) {
36294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36295 }
36296 arg1 = reinterpret_cast< wxWindow * >(argp1);
36297 {
36298 PyThreadState* __tstate = wxPyBeginAllowThreads();
36299 (arg1)->SetFocusFromKbd();
36300 wxPyEndAllowThreads(__tstate);
36301 if (PyErr_Occurred()) SWIG_fail;
36302 }
36303 resultobj = SWIG_Py_Void();
36304 return resultobj;
36305 fail:
36306 return NULL;
36307 }
36308
36309
36310 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36311 PyObject *resultobj = 0;
36312 wxWindow *result = 0 ;
36313
36314 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36315 {
36316 if (!wxPyCheckForApp()) SWIG_fail;
36317 PyThreadState* __tstate = wxPyBeginAllowThreads();
36318 result = (wxWindow *)wxWindow::FindFocus();
36319 wxPyEndAllowThreads(__tstate);
36320 if (PyErr_Occurred()) SWIG_fail;
36321 }
36322 {
36323 resultobj = wxPyMake_wxObject(result, 0);
36324 }
36325 return resultobj;
36326 fail:
36327 return NULL;
36328 }
36329
36330
36331 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36332 PyObject *resultobj = 0;
36333 wxWindow *arg1 = (wxWindow *) 0 ;
36334 bool result;
36335 void *argp1 = 0 ;
36336 int res1 = 0 ;
36337 PyObject *swig_obj[1] ;
36338
36339 if (!args) SWIG_fail;
36340 swig_obj[0] = args;
36341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36342 if (!SWIG_IsOK(res1)) {
36343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36344 }
36345 arg1 = reinterpret_cast< wxWindow * >(argp1);
36346 {
36347 PyThreadState* __tstate = wxPyBeginAllowThreads();
36348 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36349 wxPyEndAllowThreads(__tstate);
36350 if (PyErr_Occurred()) SWIG_fail;
36351 }
36352 {
36353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36354 }
36355 return resultobj;
36356 fail:
36357 return NULL;
36358 }
36359
36360
36361 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36362 PyObject *resultobj = 0;
36363 wxWindow *arg1 = (wxWindow *) 0 ;
36364 bool result;
36365 void *argp1 = 0 ;
36366 int res1 = 0 ;
36367 PyObject *swig_obj[1] ;
36368
36369 if (!args) SWIG_fail;
36370 swig_obj[0] = args;
36371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36372 if (!SWIG_IsOK(res1)) {
36373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36374 }
36375 arg1 = reinterpret_cast< wxWindow * >(argp1);
36376 {
36377 PyThreadState* __tstate = wxPyBeginAllowThreads();
36378 result = (bool)((wxWindow const *)arg1)->CanAcceptFocus();
36379 wxPyEndAllowThreads(__tstate);
36380 if (PyErr_Occurred()) SWIG_fail;
36381 }
36382 {
36383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36384 }
36385 return resultobj;
36386 fail:
36387 return NULL;
36388 }
36389
36390
36391 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36392 PyObject *resultobj = 0;
36393 wxWindow *arg1 = (wxWindow *) 0 ;
36394 bool result;
36395 void *argp1 = 0 ;
36396 int res1 = 0 ;
36397 PyObject *swig_obj[1] ;
36398
36399 if (!args) SWIG_fail;
36400 swig_obj[0] = args;
36401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36402 if (!SWIG_IsOK(res1)) {
36403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36404 }
36405 arg1 = reinterpret_cast< wxWindow * >(argp1);
36406 {
36407 PyThreadState* __tstate = wxPyBeginAllowThreads();
36408 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36409 wxPyEndAllowThreads(__tstate);
36410 if (PyErr_Occurred()) SWIG_fail;
36411 }
36412 {
36413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36414 }
36415 return resultobj;
36416 fail:
36417 return NULL;
36418 }
36419
36420
36421 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36422 PyObject *resultobj = 0;
36423 wxWindow *arg1 = (wxWindow *) 0 ;
36424 bool result;
36425 void *argp1 = 0 ;
36426 int res1 = 0 ;
36427 PyObject *swig_obj[1] ;
36428
36429 if (!args) SWIG_fail;
36430 swig_obj[0] = args;
36431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36432 if (!SWIG_IsOK(res1)) {
36433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36434 }
36435 arg1 = reinterpret_cast< wxWindow * >(argp1);
36436 {
36437 PyThreadState* __tstate = wxPyBeginAllowThreads();
36438 result = (bool)((wxWindow const *)arg1)->CanAcceptFocusFromKeyboard();
36439 wxPyEndAllowThreads(__tstate);
36440 if (PyErr_Occurred()) SWIG_fail;
36441 }
36442 {
36443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36444 }
36445 return resultobj;
36446 fail:
36447 return NULL;
36448 }
36449
36450
36451 SWIGINTERN PyObject *_wrap_Window_NavigateIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36452 PyObject *resultobj = 0;
36453 wxWindow *arg1 = (wxWindow *) 0 ;
36454 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36455 bool result;
36456 void *argp1 = 0 ;
36457 int res1 = 0 ;
36458 int val2 ;
36459 int ecode2 = 0 ;
36460 PyObject * obj0 = 0 ;
36461 PyObject * obj1 = 0 ;
36462 char * kwnames[] = {
36463 (char *) "self",(char *) "flags", NULL
36464 };
36465
36466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_NavigateIn",kwnames,&obj0,&obj1)) SWIG_fail;
36467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36468 if (!SWIG_IsOK(res1)) {
36469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_NavigateIn" "', expected argument " "1"" of type '" "wxWindow *""'");
36470 }
36471 arg1 = reinterpret_cast< wxWindow * >(argp1);
36472 if (obj1) {
36473 ecode2 = SWIG_AsVal_int(obj1, &val2);
36474 if (!SWIG_IsOK(ecode2)) {
36475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_NavigateIn" "', expected argument " "2"" of type '" "int""'");
36476 }
36477 arg2 = static_cast< int >(val2);
36478 }
36479 {
36480 PyThreadState* __tstate = wxPyBeginAllowThreads();
36481 result = (bool)(arg1)->NavigateIn(arg2);
36482 wxPyEndAllowThreads(__tstate);
36483 if (PyErr_Occurred()) SWIG_fail;
36484 }
36485 {
36486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36487 }
36488 return resultobj;
36489 fail:
36490 return NULL;
36491 }
36492
36493
36494 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36495 PyObject *resultobj = 0;
36496 wxWindow *arg1 = (wxWindow *) 0 ;
36497 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36498 bool result;
36499 void *argp1 = 0 ;
36500 int res1 = 0 ;
36501 int val2 ;
36502 int ecode2 = 0 ;
36503 PyObject * obj0 = 0 ;
36504 PyObject * obj1 = 0 ;
36505 char * kwnames[] = {
36506 (char *) "self",(char *) "flags", NULL
36507 };
36508
36509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36511 if (!SWIG_IsOK(res1)) {
36512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36513 }
36514 arg1 = reinterpret_cast< wxWindow * >(argp1);
36515 if (obj1) {
36516 ecode2 = SWIG_AsVal_int(obj1, &val2);
36517 if (!SWIG_IsOK(ecode2)) {
36518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36519 }
36520 arg2 = static_cast< int >(val2);
36521 }
36522 {
36523 PyThreadState* __tstate = wxPyBeginAllowThreads();
36524 result = (bool)(arg1)->Navigate(arg2);
36525 wxPyEndAllowThreads(__tstate);
36526 if (PyErr_Occurred()) SWIG_fail;
36527 }
36528 {
36529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36530 }
36531 return resultobj;
36532 fail:
36533 return NULL;
36534 }
36535
36536
36537 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36538 PyObject *resultobj = 0;
36539 wxWindow *arg1 = (wxWindow *) 0 ;
36540 wxWindow *arg2 = (wxWindow *) 0 ;
36541 void *argp1 = 0 ;
36542 int res1 = 0 ;
36543 void *argp2 = 0 ;
36544 int res2 = 0 ;
36545 PyObject * obj0 = 0 ;
36546 PyObject * obj1 = 0 ;
36547 char * kwnames[] = {
36548 (char *) "self",(char *) "win", NULL
36549 };
36550
36551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36553 if (!SWIG_IsOK(res1)) {
36554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36555 }
36556 arg1 = reinterpret_cast< wxWindow * >(argp1);
36557 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36558 if (!SWIG_IsOK(res2)) {
36559 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36560 }
36561 arg2 = reinterpret_cast< wxWindow * >(argp2);
36562 {
36563 PyThreadState* __tstate = wxPyBeginAllowThreads();
36564 (arg1)->MoveAfterInTabOrder(arg2);
36565 wxPyEndAllowThreads(__tstate);
36566 if (PyErr_Occurred()) SWIG_fail;
36567 }
36568 resultobj = SWIG_Py_Void();
36569 return resultobj;
36570 fail:
36571 return NULL;
36572 }
36573
36574
36575 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36576 PyObject *resultobj = 0;
36577 wxWindow *arg1 = (wxWindow *) 0 ;
36578 wxWindow *arg2 = (wxWindow *) 0 ;
36579 void *argp1 = 0 ;
36580 int res1 = 0 ;
36581 void *argp2 = 0 ;
36582 int res2 = 0 ;
36583 PyObject * obj0 = 0 ;
36584 PyObject * obj1 = 0 ;
36585 char * kwnames[] = {
36586 (char *) "self",(char *) "win", NULL
36587 };
36588
36589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36591 if (!SWIG_IsOK(res1)) {
36592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36593 }
36594 arg1 = reinterpret_cast< wxWindow * >(argp1);
36595 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36596 if (!SWIG_IsOK(res2)) {
36597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36598 }
36599 arg2 = reinterpret_cast< wxWindow * >(argp2);
36600 {
36601 PyThreadState* __tstate = wxPyBeginAllowThreads();
36602 (arg1)->MoveBeforeInTabOrder(arg2);
36603 wxPyEndAllowThreads(__tstate);
36604 if (PyErr_Occurred()) SWIG_fail;
36605 }
36606 resultobj = SWIG_Py_Void();
36607 return resultobj;
36608 fail:
36609 return NULL;
36610 }
36611
36612
36613 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36614 PyObject *resultobj = 0;
36615 wxWindow *arg1 = (wxWindow *) 0 ;
36616 PyObject *result = 0 ;
36617 void *argp1 = 0 ;
36618 int res1 = 0 ;
36619 PyObject *swig_obj[1] ;
36620
36621 if (!args) SWIG_fail;
36622 swig_obj[0] = args;
36623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36624 if (!SWIG_IsOK(res1)) {
36625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36626 }
36627 arg1 = reinterpret_cast< wxWindow * >(argp1);
36628 {
36629 PyThreadState* __tstate = wxPyBeginAllowThreads();
36630 result = (PyObject *)wxWindow_GetChildren(arg1);
36631 wxPyEndAllowThreads(__tstate);
36632 if (PyErr_Occurred()) SWIG_fail;
36633 }
36634 resultobj = result;
36635 return resultobj;
36636 fail:
36637 return NULL;
36638 }
36639
36640
36641 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36642 PyObject *resultobj = 0;
36643 wxWindow *arg1 = (wxWindow *) 0 ;
36644 wxWindow *result = 0 ;
36645 void *argp1 = 0 ;
36646 int res1 = 0 ;
36647 PyObject *swig_obj[1] ;
36648
36649 if (!args) SWIG_fail;
36650 swig_obj[0] = args;
36651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36652 if (!SWIG_IsOK(res1)) {
36653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36654 }
36655 arg1 = reinterpret_cast< wxWindow * >(argp1);
36656 {
36657 PyThreadState* __tstate = wxPyBeginAllowThreads();
36658 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36659 wxPyEndAllowThreads(__tstate);
36660 if (PyErr_Occurred()) SWIG_fail;
36661 }
36662 {
36663 resultobj = wxPyMake_wxObject(result, 0);
36664 }
36665 return resultobj;
36666 fail:
36667 return NULL;
36668 }
36669
36670
36671 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36672 PyObject *resultobj = 0;
36673 wxWindow *arg1 = (wxWindow *) 0 ;
36674 wxWindow *result = 0 ;
36675 void *argp1 = 0 ;
36676 int res1 = 0 ;
36677 PyObject *swig_obj[1] ;
36678
36679 if (!args) SWIG_fail;
36680 swig_obj[0] = args;
36681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36682 if (!SWIG_IsOK(res1)) {
36683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36684 }
36685 arg1 = reinterpret_cast< wxWindow * >(argp1);
36686 {
36687 PyThreadState* __tstate = wxPyBeginAllowThreads();
36688 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36689 wxPyEndAllowThreads(__tstate);
36690 if (PyErr_Occurred()) SWIG_fail;
36691 }
36692 {
36693 resultobj = wxPyMake_wxObject(result, 0);
36694 }
36695 return resultobj;
36696 fail:
36697 return NULL;
36698 }
36699
36700
36701 SWIGINTERN PyObject *_wrap_Window_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36702 PyObject *resultobj = 0;
36703 wxWindow *arg1 = (wxWindow *) 0 ;
36704 wxWindow *result = 0 ;
36705 void *argp1 = 0 ;
36706 int res1 = 0 ;
36707 PyObject *swig_obj[1] ;
36708
36709 if (!args) SWIG_fail;
36710 swig_obj[0] = args;
36711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36712 if (!SWIG_IsOK(res1)) {
36713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
36714 }
36715 arg1 = reinterpret_cast< wxWindow * >(argp1);
36716 {
36717 PyThreadState* __tstate = wxPyBeginAllowThreads();
36718 result = (wxWindow *)wxWindow_GetTopLevelParent(arg1);
36719 wxPyEndAllowThreads(__tstate);
36720 if (PyErr_Occurred()) SWIG_fail;
36721 }
36722 {
36723 resultobj = wxPyMake_wxObject(result, 0);
36724 }
36725 return resultobj;
36726 fail:
36727 return NULL;
36728 }
36729
36730
36731 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36732 PyObject *resultobj = 0;
36733 wxWindow *arg1 = (wxWindow *) 0 ;
36734 bool result;
36735 void *argp1 = 0 ;
36736 int res1 = 0 ;
36737 PyObject *swig_obj[1] ;
36738
36739 if (!args) SWIG_fail;
36740 swig_obj[0] = args;
36741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36742 if (!SWIG_IsOK(res1)) {
36743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36744 }
36745 arg1 = reinterpret_cast< wxWindow * >(argp1);
36746 {
36747 PyThreadState* __tstate = wxPyBeginAllowThreads();
36748 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36749 wxPyEndAllowThreads(__tstate);
36750 if (PyErr_Occurred()) SWIG_fail;
36751 }
36752 {
36753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36754 }
36755 return resultobj;
36756 fail:
36757 return NULL;
36758 }
36759
36760
36761 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36762 PyObject *resultobj = 0;
36763 wxWindow *arg1 = (wxWindow *) 0 ;
36764 wxWindow *arg2 = (wxWindow *) 0 ;
36765 bool result;
36766 void *argp1 = 0 ;
36767 int res1 = 0 ;
36768 void *argp2 = 0 ;
36769 int res2 = 0 ;
36770 PyObject * obj0 = 0 ;
36771 PyObject * obj1 = 0 ;
36772 char * kwnames[] = {
36773 (char *) "self",(char *) "newParent", NULL
36774 };
36775
36776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36778 if (!SWIG_IsOK(res1)) {
36779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36780 }
36781 arg1 = reinterpret_cast< wxWindow * >(argp1);
36782 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36783 if (!SWIG_IsOK(res2)) {
36784 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36785 }
36786 arg2 = reinterpret_cast< wxWindow * >(argp2);
36787 {
36788 PyThreadState* __tstate = wxPyBeginAllowThreads();
36789 result = (bool)(arg1)->Reparent(arg2);
36790 wxPyEndAllowThreads(__tstate);
36791 if (PyErr_Occurred()) SWIG_fail;
36792 }
36793 {
36794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36795 }
36796 return resultobj;
36797 fail:
36798 return NULL;
36799 }
36800
36801
36802 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36803 PyObject *resultobj = 0;
36804 wxWindow *arg1 = (wxWindow *) 0 ;
36805 wxWindow *arg2 = (wxWindow *) 0 ;
36806 void *argp1 = 0 ;
36807 int res1 = 0 ;
36808 void *argp2 = 0 ;
36809 int res2 = 0 ;
36810 PyObject * obj0 = 0 ;
36811 PyObject * obj1 = 0 ;
36812 char * kwnames[] = {
36813 (char *) "self",(char *) "child", NULL
36814 };
36815
36816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36818 if (!SWIG_IsOK(res1)) {
36819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36820 }
36821 arg1 = reinterpret_cast< wxWindow * >(argp1);
36822 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36823 if (!SWIG_IsOK(res2)) {
36824 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36825 }
36826 arg2 = reinterpret_cast< wxWindow * >(argp2);
36827 {
36828 PyThreadState* __tstate = wxPyBeginAllowThreads();
36829 (arg1)->AddChild(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_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36841 PyObject *resultobj = 0;
36842 wxWindow *arg1 = (wxWindow *) 0 ;
36843 wxWindow *arg2 = (wxWindow *) 0 ;
36844 void *argp1 = 0 ;
36845 int res1 = 0 ;
36846 void *argp2 = 0 ;
36847 int res2 = 0 ;
36848 PyObject * obj0 = 0 ;
36849 PyObject * obj1 = 0 ;
36850 char * kwnames[] = {
36851 (char *) "self",(char *) "child", NULL
36852 };
36853
36854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36856 if (!SWIG_IsOK(res1)) {
36857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36858 }
36859 arg1 = reinterpret_cast< wxWindow * >(argp1);
36860 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36861 if (!SWIG_IsOK(res2)) {
36862 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36863 }
36864 arg2 = reinterpret_cast< wxWindow * >(argp2);
36865 {
36866 PyThreadState* __tstate = wxPyBeginAllowThreads();
36867 (arg1)->RemoveChild(arg2);
36868 wxPyEndAllowThreads(__tstate);
36869 if (PyErr_Occurred()) SWIG_fail;
36870 }
36871 resultobj = SWIG_Py_Void();
36872 return resultobj;
36873 fail:
36874 return NULL;
36875 }
36876
36877
36878 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36879 PyObject *resultobj = 0;
36880 wxWindow *arg1 = (wxWindow *) 0 ;
36881 bool arg2 ;
36882 void *argp1 = 0 ;
36883 int res1 = 0 ;
36884 bool val2 ;
36885 int ecode2 = 0 ;
36886 PyObject * obj0 = 0 ;
36887 PyObject * obj1 = 0 ;
36888 char * kwnames[] = {
36889 (char *) "self",(char *) "on", NULL
36890 };
36891
36892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36894 if (!SWIG_IsOK(res1)) {
36895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36896 }
36897 arg1 = reinterpret_cast< wxWindow * >(argp1);
36898 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36899 if (!SWIG_IsOK(ecode2)) {
36900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36901 }
36902 arg2 = static_cast< bool >(val2);
36903 {
36904 PyThreadState* __tstate = wxPyBeginAllowThreads();
36905 wxWindow_SetDoubleBuffered(arg1,arg2);
36906 wxPyEndAllowThreads(__tstate);
36907 if (PyErr_Occurred()) SWIG_fail;
36908 }
36909 resultobj = SWIG_Py_Void();
36910 return resultobj;
36911 fail:
36912 return NULL;
36913 }
36914
36915
36916 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36917 PyObject *resultobj = 0;
36918 wxWindow *arg1 = (wxWindow *) 0 ;
36919 long arg2 ;
36920 wxWindow *result = 0 ;
36921 void *argp1 = 0 ;
36922 int res1 = 0 ;
36923 long val2 ;
36924 int ecode2 = 0 ;
36925 PyObject * obj0 = 0 ;
36926 PyObject * obj1 = 0 ;
36927 char * kwnames[] = {
36928 (char *) "self",(char *) "winid", NULL
36929 };
36930
36931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36933 if (!SWIG_IsOK(res1)) {
36934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36935 }
36936 arg1 = reinterpret_cast< wxWindow * >(argp1);
36937 ecode2 = SWIG_AsVal_long(obj1, &val2);
36938 if (!SWIG_IsOK(ecode2)) {
36939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36940 }
36941 arg2 = static_cast< long >(val2);
36942 {
36943 PyThreadState* __tstate = wxPyBeginAllowThreads();
36944 result = (wxWindow *)(arg1)->FindWindow(arg2);
36945 wxPyEndAllowThreads(__tstate);
36946 if (PyErr_Occurred()) SWIG_fail;
36947 }
36948 {
36949 resultobj = wxPyMake_wxObject(result, 0);
36950 }
36951 return resultobj;
36952 fail:
36953 return NULL;
36954 }
36955
36956
36957 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36958 PyObject *resultobj = 0;
36959 wxWindow *arg1 = (wxWindow *) 0 ;
36960 wxString *arg2 = 0 ;
36961 wxWindow *result = 0 ;
36962 void *argp1 = 0 ;
36963 int res1 = 0 ;
36964 bool temp2 = false ;
36965 PyObject * obj0 = 0 ;
36966 PyObject * obj1 = 0 ;
36967 char * kwnames[] = {
36968 (char *) "self",(char *) "name", NULL
36969 };
36970
36971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36973 if (!SWIG_IsOK(res1)) {
36974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36975 }
36976 arg1 = reinterpret_cast< wxWindow * >(argp1);
36977 {
36978 arg2 = wxString_in_helper(obj1);
36979 if (arg2 == NULL) SWIG_fail;
36980 temp2 = true;
36981 }
36982 {
36983 PyThreadState* __tstate = wxPyBeginAllowThreads();
36984 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36985 wxPyEndAllowThreads(__tstate);
36986 if (PyErr_Occurred()) SWIG_fail;
36987 }
36988 {
36989 resultobj = wxPyMake_wxObject(result, 0);
36990 }
36991 {
36992 if (temp2)
36993 delete arg2;
36994 }
36995 return resultobj;
36996 fail:
36997 {
36998 if (temp2)
36999 delete arg2;
37000 }
37001 return NULL;
37002 }
37003
37004
37005 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37006 PyObject *resultobj = 0;
37007 wxWindow *arg1 = (wxWindow *) 0 ;
37008 wxEvtHandler *result = 0 ;
37009 void *argp1 = 0 ;
37010 int res1 = 0 ;
37011 PyObject *swig_obj[1] ;
37012
37013 if (!args) SWIG_fail;
37014 swig_obj[0] = args;
37015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37016 if (!SWIG_IsOK(res1)) {
37017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
37018 }
37019 arg1 = reinterpret_cast< wxWindow * >(argp1);
37020 {
37021 PyThreadState* __tstate = wxPyBeginAllowThreads();
37022 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
37023 wxPyEndAllowThreads(__tstate);
37024 if (PyErr_Occurred()) SWIG_fail;
37025 }
37026 {
37027 resultobj = wxPyMake_wxObject(result, 0);
37028 }
37029 return resultobj;
37030 fail:
37031 return NULL;
37032 }
37033
37034
37035 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37036 PyObject *resultobj = 0;
37037 wxWindow *arg1 = (wxWindow *) 0 ;
37038 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37039 void *argp1 = 0 ;
37040 int res1 = 0 ;
37041 void *argp2 = 0 ;
37042 int res2 = 0 ;
37043 PyObject * obj0 = 0 ;
37044 PyObject * obj1 = 0 ;
37045 char * kwnames[] = {
37046 (char *) "self",(char *) "handler", NULL
37047 };
37048
37049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37051 if (!SWIG_IsOK(res1)) {
37052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37053 }
37054 arg1 = reinterpret_cast< wxWindow * >(argp1);
37055 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37056 if (!SWIG_IsOK(res2)) {
37057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37058 }
37059 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37060 {
37061 PyThreadState* __tstate = wxPyBeginAllowThreads();
37062 (arg1)->SetEventHandler(arg2);
37063 wxPyEndAllowThreads(__tstate);
37064 if (PyErr_Occurred()) SWIG_fail;
37065 }
37066 resultobj = SWIG_Py_Void();
37067 return resultobj;
37068 fail:
37069 return NULL;
37070 }
37071
37072
37073 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37074 PyObject *resultobj = 0;
37075 wxWindow *arg1 = (wxWindow *) 0 ;
37076 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37077 void *argp1 = 0 ;
37078 int res1 = 0 ;
37079 void *argp2 = 0 ;
37080 int res2 = 0 ;
37081 PyObject * obj0 = 0 ;
37082 PyObject * obj1 = 0 ;
37083 char * kwnames[] = {
37084 (char *) "self",(char *) "handler", NULL
37085 };
37086
37087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37089 if (!SWIG_IsOK(res1)) {
37090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37091 }
37092 arg1 = reinterpret_cast< wxWindow * >(argp1);
37093 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37094 if (!SWIG_IsOK(res2)) {
37095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37096 }
37097 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37098 {
37099 PyThreadState* __tstate = wxPyBeginAllowThreads();
37100 (arg1)->PushEventHandler(arg2);
37101 wxPyEndAllowThreads(__tstate);
37102 if (PyErr_Occurred()) SWIG_fail;
37103 }
37104 resultobj = SWIG_Py_Void();
37105 return resultobj;
37106 fail:
37107 return NULL;
37108 }
37109
37110
37111 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37112 PyObject *resultobj = 0;
37113 wxWindow *arg1 = (wxWindow *) 0 ;
37114 bool arg2 = (bool) false ;
37115 wxEvtHandler *result = 0 ;
37116 void *argp1 = 0 ;
37117 int res1 = 0 ;
37118 bool val2 ;
37119 int ecode2 = 0 ;
37120 PyObject * obj0 = 0 ;
37121 PyObject * obj1 = 0 ;
37122 char * kwnames[] = {
37123 (char *) "self",(char *) "deleteHandler", NULL
37124 };
37125
37126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37128 if (!SWIG_IsOK(res1)) {
37129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37130 }
37131 arg1 = reinterpret_cast< wxWindow * >(argp1);
37132 if (obj1) {
37133 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37134 if (!SWIG_IsOK(ecode2)) {
37135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
37136 }
37137 arg2 = static_cast< bool >(val2);
37138 }
37139 {
37140 PyThreadState* __tstate = wxPyBeginAllowThreads();
37141 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
37142 wxPyEndAllowThreads(__tstate);
37143 if (PyErr_Occurred()) SWIG_fail;
37144 }
37145 {
37146 resultobj = wxPyMake_wxObject(result, 0);
37147 }
37148 return resultobj;
37149 fail:
37150 return NULL;
37151 }
37152
37153
37154 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37155 PyObject *resultobj = 0;
37156 wxWindow *arg1 = (wxWindow *) 0 ;
37157 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37158 bool result;
37159 void *argp1 = 0 ;
37160 int res1 = 0 ;
37161 void *argp2 = 0 ;
37162 int res2 = 0 ;
37163 PyObject * obj0 = 0 ;
37164 PyObject * obj1 = 0 ;
37165 char * kwnames[] = {
37166 (char *) "self",(char *) "handler", NULL
37167 };
37168
37169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37171 if (!SWIG_IsOK(res1)) {
37172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37173 }
37174 arg1 = reinterpret_cast< wxWindow * >(argp1);
37175 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37176 if (!SWIG_IsOK(res2)) {
37177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37178 }
37179 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37180 {
37181 PyThreadState* __tstate = wxPyBeginAllowThreads();
37182 result = (bool)(arg1)->RemoveEventHandler(arg2);
37183 wxPyEndAllowThreads(__tstate);
37184 if (PyErr_Occurred()) SWIG_fail;
37185 }
37186 {
37187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37188 }
37189 return resultobj;
37190 fail:
37191 return NULL;
37192 }
37193
37194
37195 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37196 PyObject *resultobj = 0;
37197 wxWindow *arg1 = (wxWindow *) 0 ;
37198 wxValidator *arg2 = 0 ;
37199 void *argp1 = 0 ;
37200 int res1 = 0 ;
37201 void *argp2 = 0 ;
37202 int res2 = 0 ;
37203 PyObject * obj0 = 0 ;
37204 PyObject * obj1 = 0 ;
37205 char * kwnames[] = {
37206 (char *) "self",(char *) "validator", NULL
37207 };
37208
37209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
37210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37211 if (!SWIG_IsOK(res1)) {
37212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37213 }
37214 arg1 = reinterpret_cast< wxWindow * >(argp1);
37215 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
37216 if (!SWIG_IsOK(res2)) {
37217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37218 }
37219 if (!argp2) {
37220 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37221 }
37222 arg2 = reinterpret_cast< wxValidator * >(argp2);
37223 {
37224 PyThreadState* __tstate = wxPyBeginAllowThreads();
37225 (arg1)->SetValidator((wxValidator const &)*arg2);
37226 wxPyEndAllowThreads(__tstate);
37227 if (PyErr_Occurred()) SWIG_fail;
37228 }
37229 resultobj = SWIG_Py_Void();
37230 return resultobj;
37231 fail:
37232 return NULL;
37233 }
37234
37235
37236 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37237 PyObject *resultobj = 0;
37238 wxWindow *arg1 = (wxWindow *) 0 ;
37239 wxValidator *result = 0 ;
37240 void *argp1 = 0 ;
37241 int res1 = 0 ;
37242 PyObject *swig_obj[1] ;
37243
37244 if (!args) SWIG_fail;
37245 swig_obj[0] = args;
37246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37247 if (!SWIG_IsOK(res1)) {
37248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37249 }
37250 arg1 = reinterpret_cast< wxWindow * >(argp1);
37251 {
37252 PyThreadState* __tstate = wxPyBeginAllowThreads();
37253 result = (wxValidator *)(arg1)->GetValidator();
37254 wxPyEndAllowThreads(__tstate);
37255 if (PyErr_Occurred()) SWIG_fail;
37256 }
37257 {
37258 resultobj = wxPyMake_wxObject(result, (bool)0);
37259 }
37260 return resultobj;
37261 fail:
37262 return NULL;
37263 }
37264
37265
37266 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37267 PyObject *resultobj = 0;
37268 wxWindow *arg1 = (wxWindow *) 0 ;
37269 bool result;
37270 void *argp1 = 0 ;
37271 int res1 = 0 ;
37272 PyObject *swig_obj[1] ;
37273
37274 if (!args) SWIG_fail;
37275 swig_obj[0] = args;
37276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37277 if (!SWIG_IsOK(res1)) {
37278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
37279 }
37280 arg1 = reinterpret_cast< wxWindow * >(argp1);
37281 {
37282 PyThreadState* __tstate = wxPyBeginAllowThreads();
37283 result = (bool)(arg1)->Validate();
37284 wxPyEndAllowThreads(__tstate);
37285 if (PyErr_Occurred()) SWIG_fail;
37286 }
37287 {
37288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37289 }
37290 return resultobj;
37291 fail:
37292 return NULL;
37293 }
37294
37295
37296 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37297 PyObject *resultobj = 0;
37298 wxWindow *arg1 = (wxWindow *) 0 ;
37299 bool result;
37300 void *argp1 = 0 ;
37301 int res1 = 0 ;
37302 PyObject *swig_obj[1] ;
37303
37304 if (!args) SWIG_fail;
37305 swig_obj[0] = args;
37306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37307 if (!SWIG_IsOK(res1)) {
37308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37309 }
37310 arg1 = reinterpret_cast< wxWindow * >(argp1);
37311 {
37312 PyThreadState* __tstate = wxPyBeginAllowThreads();
37313 result = (bool)(arg1)->TransferDataToWindow();
37314 wxPyEndAllowThreads(__tstate);
37315 if (PyErr_Occurred()) SWIG_fail;
37316 }
37317 {
37318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37319 }
37320 return resultobj;
37321 fail:
37322 return NULL;
37323 }
37324
37325
37326 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37327 PyObject *resultobj = 0;
37328 wxWindow *arg1 = (wxWindow *) 0 ;
37329 bool result;
37330 void *argp1 = 0 ;
37331 int res1 = 0 ;
37332 PyObject *swig_obj[1] ;
37333
37334 if (!args) SWIG_fail;
37335 swig_obj[0] = args;
37336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37337 if (!SWIG_IsOK(res1)) {
37338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37339 }
37340 arg1 = reinterpret_cast< wxWindow * >(argp1);
37341 {
37342 PyThreadState* __tstate = wxPyBeginAllowThreads();
37343 result = (bool)(arg1)->TransferDataFromWindow();
37344 wxPyEndAllowThreads(__tstate);
37345 if (PyErr_Occurred()) SWIG_fail;
37346 }
37347 {
37348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37349 }
37350 return resultobj;
37351 fail:
37352 return NULL;
37353 }
37354
37355
37356 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37357 PyObject *resultobj = 0;
37358 wxWindow *arg1 = (wxWindow *) 0 ;
37359 void *argp1 = 0 ;
37360 int res1 = 0 ;
37361 PyObject *swig_obj[1] ;
37362
37363 if (!args) SWIG_fail;
37364 swig_obj[0] = args;
37365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37366 if (!SWIG_IsOK(res1)) {
37367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37368 }
37369 arg1 = reinterpret_cast< wxWindow * >(argp1);
37370 {
37371 PyThreadState* __tstate = wxPyBeginAllowThreads();
37372 (arg1)->InitDialog();
37373 wxPyEndAllowThreads(__tstate);
37374 if (PyErr_Occurred()) SWIG_fail;
37375 }
37376 resultobj = SWIG_Py_Void();
37377 return resultobj;
37378 fail:
37379 return NULL;
37380 }
37381
37382
37383 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37384 PyObject *resultobj = 0;
37385 wxWindow *arg1 = (wxWindow *) 0 ;
37386 wxAcceleratorTable *arg2 = 0 ;
37387 void *argp1 = 0 ;
37388 int res1 = 0 ;
37389 void *argp2 = 0 ;
37390 int res2 = 0 ;
37391 PyObject * obj0 = 0 ;
37392 PyObject * obj1 = 0 ;
37393 char * kwnames[] = {
37394 (char *) "self",(char *) "accel", NULL
37395 };
37396
37397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37399 if (!SWIG_IsOK(res1)) {
37400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37401 }
37402 arg1 = reinterpret_cast< wxWindow * >(argp1);
37403 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37404 if (!SWIG_IsOK(res2)) {
37405 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37406 }
37407 if (!argp2) {
37408 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37409 }
37410 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37411 {
37412 PyThreadState* __tstate = wxPyBeginAllowThreads();
37413 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37414 wxPyEndAllowThreads(__tstate);
37415 if (PyErr_Occurred()) SWIG_fail;
37416 }
37417 resultobj = SWIG_Py_Void();
37418 return resultobj;
37419 fail:
37420 return NULL;
37421 }
37422
37423
37424 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37425 PyObject *resultobj = 0;
37426 wxWindow *arg1 = (wxWindow *) 0 ;
37427 wxAcceleratorTable *result = 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_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37437 }
37438 arg1 = reinterpret_cast< wxWindow * >(argp1);
37439 {
37440 PyThreadState* __tstate = wxPyBeginAllowThreads();
37441 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37442 wxPyEndAllowThreads(__tstate);
37443 if (PyErr_Occurred()) SWIG_fail;
37444 }
37445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37446 return resultobj;
37447 fail:
37448 return NULL;
37449 }
37450
37451
37452 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37453 PyObject *resultobj = 0;
37454 wxWindow *arg1 = (wxWindow *) 0 ;
37455 int arg2 ;
37456 int arg3 ;
37457 int arg4 ;
37458 bool result;
37459 void *argp1 = 0 ;
37460 int res1 = 0 ;
37461 int val2 ;
37462 int ecode2 = 0 ;
37463 int val3 ;
37464 int ecode3 = 0 ;
37465 int val4 ;
37466 int ecode4 = 0 ;
37467 PyObject * obj0 = 0 ;
37468 PyObject * obj1 = 0 ;
37469 PyObject * obj2 = 0 ;
37470 PyObject * obj3 = 0 ;
37471 char * kwnames[] = {
37472 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37473 };
37474
37475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37477 if (!SWIG_IsOK(res1)) {
37478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37479 }
37480 arg1 = reinterpret_cast< wxWindow * >(argp1);
37481 ecode2 = SWIG_AsVal_int(obj1, &val2);
37482 if (!SWIG_IsOK(ecode2)) {
37483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37484 }
37485 arg2 = static_cast< int >(val2);
37486 ecode3 = SWIG_AsVal_int(obj2, &val3);
37487 if (!SWIG_IsOK(ecode3)) {
37488 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37489 }
37490 arg3 = static_cast< int >(val3);
37491 ecode4 = SWIG_AsVal_int(obj3, &val4);
37492 if (!SWIG_IsOK(ecode4)) {
37493 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37494 }
37495 arg4 = static_cast< int >(val4);
37496 {
37497 PyThreadState* __tstate = wxPyBeginAllowThreads();
37498 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37499 wxPyEndAllowThreads(__tstate);
37500 if (PyErr_Occurred()) SWIG_fail;
37501 }
37502 {
37503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37504 }
37505 return resultobj;
37506 fail:
37507 return NULL;
37508 }
37509
37510
37511 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37512 PyObject *resultobj = 0;
37513 wxWindow *arg1 = (wxWindow *) 0 ;
37514 int arg2 ;
37515 bool result;
37516 void *argp1 = 0 ;
37517 int res1 = 0 ;
37518 int val2 ;
37519 int ecode2 = 0 ;
37520 PyObject * obj0 = 0 ;
37521 PyObject * obj1 = 0 ;
37522 char * kwnames[] = {
37523 (char *) "self",(char *) "hotkeyId", NULL
37524 };
37525
37526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37528 if (!SWIG_IsOK(res1)) {
37529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37530 }
37531 arg1 = reinterpret_cast< wxWindow * >(argp1);
37532 ecode2 = SWIG_AsVal_int(obj1, &val2);
37533 if (!SWIG_IsOK(ecode2)) {
37534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37535 }
37536 arg2 = static_cast< int >(val2);
37537 {
37538 PyThreadState* __tstate = wxPyBeginAllowThreads();
37539 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37540 wxPyEndAllowThreads(__tstate);
37541 if (PyErr_Occurred()) SWIG_fail;
37542 }
37543 {
37544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37545 }
37546 return resultobj;
37547 fail:
37548 return NULL;
37549 }
37550
37551
37552 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37553 PyObject *resultobj = 0;
37554 wxWindow *arg1 = (wxWindow *) 0 ;
37555 wxPoint *arg2 = 0 ;
37556 wxPoint result;
37557 void *argp1 = 0 ;
37558 int res1 = 0 ;
37559 wxPoint temp2 ;
37560 PyObject * obj0 = 0 ;
37561 PyObject * obj1 = 0 ;
37562 char * kwnames[] = {
37563 (char *) "self",(char *) "pt", NULL
37564 };
37565
37566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37568 if (!SWIG_IsOK(res1)) {
37569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37570 }
37571 arg1 = reinterpret_cast< wxWindow * >(argp1);
37572 {
37573 arg2 = &temp2;
37574 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37575 }
37576 {
37577 PyThreadState* __tstate = wxPyBeginAllowThreads();
37578 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37579 wxPyEndAllowThreads(__tstate);
37580 if (PyErr_Occurred()) SWIG_fail;
37581 }
37582 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37583 return resultobj;
37584 fail:
37585 return NULL;
37586 }
37587
37588
37589 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37590 PyObject *resultobj = 0;
37591 wxWindow *arg1 = (wxWindow *) 0 ;
37592 wxSize *arg2 = 0 ;
37593 wxSize result;
37594 void *argp1 = 0 ;
37595 int res1 = 0 ;
37596 wxSize temp2 ;
37597 PyObject * obj0 = 0 ;
37598 PyObject * obj1 = 0 ;
37599 char * kwnames[] = {
37600 (char *) "self",(char *) "sz", NULL
37601 };
37602
37603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37605 if (!SWIG_IsOK(res1)) {
37606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37607 }
37608 arg1 = reinterpret_cast< wxWindow * >(argp1);
37609 {
37610 arg2 = &temp2;
37611 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37612 }
37613 {
37614 PyThreadState* __tstate = wxPyBeginAllowThreads();
37615 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37616 wxPyEndAllowThreads(__tstate);
37617 if (PyErr_Occurred()) SWIG_fail;
37618 }
37619 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37620 return resultobj;
37621 fail:
37622 return NULL;
37623 }
37624
37625
37626 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37627 PyObject *resultobj = 0;
37628 wxWindow *arg1 = (wxWindow *) 0 ;
37629 wxPoint *arg2 = 0 ;
37630 wxPoint result;
37631 void *argp1 = 0 ;
37632 int res1 = 0 ;
37633 wxPoint temp2 ;
37634 PyObject * obj0 = 0 ;
37635 PyObject * obj1 = 0 ;
37636 char * kwnames[] = {
37637 (char *) "self",(char *) "pt", NULL
37638 };
37639
37640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37642 if (!SWIG_IsOK(res1)) {
37643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37644 }
37645 arg1 = reinterpret_cast< wxWindow * >(argp1);
37646 {
37647 arg2 = &temp2;
37648 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37649 }
37650 {
37651 PyThreadState* __tstate = wxPyBeginAllowThreads();
37652 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37653 wxPyEndAllowThreads(__tstate);
37654 if (PyErr_Occurred()) SWIG_fail;
37655 }
37656 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37657 return resultobj;
37658 fail:
37659 return NULL;
37660 }
37661
37662
37663 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37664 PyObject *resultobj = 0;
37665 wxWindow *arg1 = (wxWindow *) 0 ;
37666 wxSize *arg2 = 0 ;
37667 wxSize result;
37668 void *argp1 = 0 ;
37669 int res1 = 0 ;
37670 wxSize temp2 ;
37671 PyObject * obj0 = 0 ;
37672 PyObject * obj1 = 0 ;
37673 char * kwnames[] = {
37674 (char *) "self",(char *) "sz", NULL
37675 };
37676
37677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37679 if (!SWIG_IsOK(res1)) {
37680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37681 }
37682 arg1 = reinterpret_cast< wxWindow * >(argp1);
37683 {
37684 arg2 = &temp2;
37685 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37686 }
37687 {
37688 PyThreadState* __tstate = wxPyBeginAllowThreads();
37689 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37690 wxPyEndAllowThreads(__tstate);
37691 if (PyErr_Occurred()) SWIG_fail;
37692 }
37693 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37694 return resultobj;
37695 fail:
37696 return NULL;
37697 }
37698
37699
37700 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37701 PyObject *resultobj = 0;
37702 wxWindow *arg1 = (wxWindow *) 0 ;
37703 wxPoint *arg2 = 0 ;
37704 wxPoint result;
37705 void *argp1 = 0 ;
37706 int res1 = 0 ;
37707 wxPoint temp2 ;
37708 PyObject * obj0 = 0 ;
37709 PyObject * obj1 = 0 ;
37710 char * kwnames[] = {
37711 (char *) "self",(char *) "pt", NULL
37712 };
37713
37714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37716 if (!SWIG_IsOK(res1)) {
37717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37718 }
37719 arg1 = reinterpret_cast< wxWindow * >(argp1);
37720 {
37721 arg2 = &temp2;
37722 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37723 }
37724 {
37725 PyThreadState* __tstate = wxPyBeginAllowThreads();
37726 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37727 wxPyEndAllowThreads(__tstate);
37728 if (PyErr_Occurred()) SWIG_fail;
37729 }
37730 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37731 return resultobj;
37732 fail:
37733 return NULL;
37734 }
37735
37736
37737 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37738 PyObject *resultobj = 0;
37739 wxWindow *arg1 = (wxWindow *) 0 ;
37740 wxSize *arg2 = 0 ;
37741 wxSize result;
37742 void *argp1 = 0 ;
37743 int res1 = 0 ;
37744 wxSize temp2 ;
37745 PyObject * obj0 = 0 ;
37746 PyObject * obj1 = 0 ;
37747 char * kwnames[] = {
37748 (char *) "self",(char *) "sz", NULL
37749 };
37750
37751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37753 if (!SWIG_IsOK(res1)) {
37754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37755 }
37756 arg1 = reinterpret_cast< wxWindow * >(argp1);
37757 {
37758 arg2 = &temp2;
37759 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37760 }
37761 {
37762 PyThreadState* __tstate = wxPyBeginAllowThreads();
37763 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37764 wxPyEndAllowThreads(__tstate);
37765 if (PyErr_Occurred()) SWIG_fail;
37766 }
37767 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37768 return resultobj;
37769 fail:
37770 return NULL;
37771 }
37772
37773
37774 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37775 PyObject *resultobj = 0;
37776 wxWindow *arg1 = (wxWindow *) 0 ;
37777 int arg2 ;
37778 int arg3 ;
37779 void *argp1 = 0 ;
37780 int res1 = 0 ;
37781 int val2 ;
37782 int ecode2 = 0 ;
37783 int val3 ;
37784 int ecode3 = 0 ;
37785 PyObject * obj0 = 0 ;
37786 PyObject * obj1 = 0 ;
37787 PyObject * obj2 = 0 ;
37788 char * kwnames[] = {
37789 (char *) "self",(char *) "x",(char *) "y", NULL
37790 };
37791
37792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37794 if (!SWIG_IsOK(res1)) {
37795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37796 }
37797 arg1 = reinterpret_cast< wxWindow * >(argp1);
37798 ecode2 = SWIG_AsVal_int(obj1, &val2);
37799 if (!SWIG_IsOK(ecode2)) {
37800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37801 }
37802 arg2 = static_cast< int >(val2);
37803 ecode3 = SWIG_AsVal_int(obj2, &val3);
37804 if (!SWIG_IsOK(ecode3)) {
37805 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37806 }
37807 arg3 = static_cast< int >(val3);
37808 {
37809 PyThreadState* __tstate = wxPyBeginAllowThreads();
37810 (arg1)->WarpPointer(arg2,arg3);
37811 wxPyEndAllowThreads(__tstate);
37812 if (PyErr_Occurred()) SWIG_fail;
37813 }
37814 resultobj = SWIG_Py_Void();
37815 return resultobj;
37816 fail:
37817 return NULL;
37818 }
37819
37820
37821 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37822 PyObject *resultobj = 0;
37823 wxWindow *arg1 = (wxWindow *) 0 ;
37824 void *argp1 = 0 ;
37825 int res1 = 0 ;
37826 PyObject *swig_obj[1] ;
37827
37828 if (!args) SWIG_fail;
37829 swig_obj[0] = args;
37830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37831 if (!SWIG_IsOK(res1)) {
37832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37833 }
37834 arg1 = reinterpret_cast< wxWindow * >(argp1);
37835 {
37836 PyThreadState* __tstate = wxPyBeginAllowThreads();
37837 (arg1)->CaptureMouse();
37838 wxPyEndAllowThreads(__tstate);
37839 if (PyErr_Occurred()) SWIG_fail;
37840 }
37841 resultobj = SWIG_Py_Void();
37842 return resultobj;
37843 fail:
37844 return NULL;
37845 }
37846
37847
37848 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37849 PyObject *resultobj = 0;
37850 wxWindow *arg1 = (wxWindow *) 0 ;
37851 void *argp1 = 0 ;
37852 int res1 = 0 ;
37853 PyObject *swig_obj[1] ;
37854
37855 if (!args) SWIG_fail;
37856 swig_obj[0] = args;
37857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37858 if (!SWIG_IsOK(res1)) {
37859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37860 }
37861 arg1 = reinterpret_cast< wxWindow * >(argp1);
37862 {
37863 PyThreadState* __tstate = wxPyBeginAllowThreads();
37864 (arg1)->ReleaseMouse();
37865 wxPyEndAllowThreads(__tstate);
37866 if (PyErr_Occurred()) SWIG_fail;
37867 }
37868 resultobj = SWIG_Py_Void();
37869 return resultobj;
37870 fail:
37871 return NULL;
37872 }
37873
37874
37875 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37876 PyObject *resultobj = 0;
37877 wxWindow *result = 0 ;
37878
37879 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37880 {
37881 if (!wxPyCheckForApp()) SWIG_fail;
37882 PyThreadState* __tstate = wxPyBeginAllowThreads();
37883 result = (wxWindow *)wxWindow::GetCapture();
37884 wxPyEndAllowThreads(__tstate);
37885 if (PyErr_Occurred()) SWIG_fail;
37886 }
37887 {
37888 resultobj = wxPyMake_wxObject(result, 0);
37889 }
37890 return resultobj;
37891 fail:
37892 return NULL;
37893 }
37894
37895
37896 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37897 PyObject *resultobj = 0;
37898 wxWindow *arg1 = (wxWindow *) 0 ;
37899 bool result;
37900 void *argp1 = 0 ;
37901 int res1 = 0 ;
37902 PyObject *swig_obj[1] ;
37903
37904 if (!args) SWIG_fail;
37905 swig_obj[0] = args;
37906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37907 if (!SWIG_IsOK(res1)) {
37908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37909 }
37910 arg1 = reinterpret_cast< wxWindow * >(argp1);
37911 {
37912 PyThreadState* __tstate = wxPyBeginAllowThreads();
37913 result = (bool)((wxWindow const *)arg1)->HasCapture();
37914 wxPyEndAllowThreads(__tstate);
37915 if (PyErr_Occurred()) SWIG_fail;
37916 }
37917 {
37918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37919 }
37920 return resultobj;
37921 fail:
37922 return NULL;
37923 }
37924
37925
37926 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37927 PyObject *resultobj = 0;
37928 wxWindow *arg1 = (wxWindow *) 0 ;
37929 bool arg2 = (bool) true ;
37930 wxRect *arg3 = (wxRect *) NULL ;
37931 void *argp1 = 0 ;
37932 int res1 = 0 ;
37933 bool val2 ;
37934 int ecode2 = 0 ;
37935 void *argp3 = 0 ;
37936 int res3 = 0 ;
37937 PyObject * obj0 = 0 ;
37938 PyObject * obj1 = 0 ;
37939 PyObject * obj2 = 0 ;
37940 char * kwnames[] = {
37941 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37942 };
37943
37944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37946 if (!SWIG_IsOK(res1)) {
37947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37948 }
37949 arg1 = reinterpret_cast< wxWindow * >(argp1);
37950 if (obj1) {
37951 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37952 if (!SWIG_IsOK(ecode2)) {
37953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37954 }
37955 arg2 = static_cast< bool >(val2);
37956 }
37957 if (obj2) {
37958 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37959 if (!SWIG_IsOK(res3)) {
37960 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37961 }
37962 arg3 = reinterpret_cast< wxRect * >(argp3);
37963 }
37964 {
37965 PyThreadState* __tstate = wxPyBeginAllowThreads();
37966 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37967 wxPyEndAllowThreads(__tstate);
37968 if (PyErr_Occurred()) SWIG_fail;
37969 }
37970 resultobj = SWIG_Py_Void();
37971 return resultobj;
37972 fail:
37973 return NULL;
37974 }
37975
37976
37977 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37978 PyObject *resultobj = 0;
37979 wxWindow *arg1 = (wxWindow *) 0 ;
37980 wxRect *arg2 = 0 ;
37981 bool arg3 = (bool) true ;
37982 void *argp1 = 0 ;
37983 int res1 = 0 ;
37984 wxRect temp2 ;
37985 bool val3 ;
37986 int ecode3 = 0 ;
37987 PyObject * obj0 = 0 ;
37988 PyObject * obj1 = 0 ;
37989 PyObject * obj2 = 0 ;
37990 char * kwnames[] = {
37991 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37992 };
37993
37994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37996 if (!SWIG_IsOK(res1)) {
37997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37998 }
37999 arg1 = reinterpret_cast< wxWindow * >(argp1);
38000 {
38001 arg2 = &temp2;
38002 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38003 }
38004 if (obj2) {
38005 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38006 if (!SWIG_IsOK(ecode3)) {
38007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
38008 }
38009 arg3 = static_cast< bool >(val3);
38010 }
38011 {
38012 PyThreadState* __tstate = wxPyBeginAllowThreads();
38013 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
38014 wxPyEndAllowThreads(__tstate);
38015 if (PyErr_Occurred()) SWIG_fail;
38016 }
38017 resultobj = SWIG_Py_Void();
38018 return resultobj;
38019 fail:
38020 return NULL;
38021 }
38022
38023
38024 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38025 PyObject *resultobj = 0;
38026 wxWindow *arg1 = (wxWindow *) 0 ;
38027 void *argp1 = 0 ;
38028 int res1 = 0 ;
38029 PyObject *swig_obj[1] ;
38030
38031 if (!args) SWIG_fail;
38032 swig_obj[0] = args;
38033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38034 if (!SWIG_IsOK(res1)) {
38035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
38036 }
38037 arg1 = reinterpret_cast< wxWindow * >(argp1);
38038 {
38039 PyThreadState* __tstate = wxPyBeginAllowThreads();
38040 (arg1)->Update();
38041 wxPyEndAllowThreads(__tstate);
38042 if (PyErr_Occurred()) SWIG_fail;
38043 }
38044 resultobj = SWIG_Py_Void();
38045 return resultobj;
38046 fail:
38047 return NULL;
38048 }
38049
38050
38051 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38052 PyObject *resultobj = 0;
38053 wxWindow *arg1 = (wxWindow *) 0 ;
38054 void *argp1 = 0 ;
38055 int res1 = 0 ;
38056 PyObject *swig_obj[1] ;
38057
38058 if (!args) SWIG_fail;
38059 swig_obj[0] = args;
38060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38061 if (!SWIG_IsOK(res1)) {
38062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38063 }
38064 arg1 = reinterpret_cast< wxWindow * >(argp1);
38065 {
38066 PyThreadState* __tstate = wxPyBeginAllowThreads();
38067 (arg1)->ClearBackground();
38068 wxPyEndAllowThreads(__tstate);
38069 if (PyErr_Occurred()) SWIG_fail;
38070 }
38071 resultobj = SWIG_Py_Void();
38072 return resultobj;
38073 fail:
38074 return NULL;
38075 }
38076
38077
38078 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38079 PyObject *resultobj = 0;
38080 wxWindow *arg1 = (wxWindow *) 0 ;
38081 void *argp1 = 0 ;
38082 int res1 = 0 ;
38083 PyObject *swig_obj[1] ;
38084
38085 if (!args) SWIG_fail;
38086 swig_obj[0] = args;
38087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38088 if (!SWIG_IsOK(res1)) {
38089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
38090 }
38091 arg1 = reinterpret_cast< wxWindow * >(argp1);
38092 {
38093 PyThreadState* __tstate = wxPyBeginAllowThreads();
38094 (arg1)->Freeze();
38095 wxPyEndAllowThreads(__tstate);
38096 if (PyErr_Occurred()) SWIG_fail;
38097 }
38098 resultobj = SWIG_Py_Void();
38099 return resultobj;
38100 fail:
38101 return NULL;
38102 }
38103
38104
38105 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38106 PyObject *resultobj = 0;
38107 wxWindow *arg1 = (wxWindow *) 0 ;
38108 bool result;
38109 void *argp1 = 0 ;
38110 int res1 = 0 ;
38111 PyObject *swig_obj[1] ;
38112
38113 if (!args) SWIG_fail;
38114 swig_obj[0] = args;
38115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38116 if (!SWIG_IsOK(res1)) {
38117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
38118 }
38119 arg1 = reinterpret_cast< wxWindow * >(argp1);
38120 {
38121 PyThreadState* __tstate = wxPyBeginAllowThreads();
38122 result = (bool)((wxWindow const *)arg1)->IsFrozen();
38123 wxPyEndAllowThreads(__tstate);
38124 if (PyErr_Occurred()) SWIG_fail;
38125 }
38126 {
38127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38128 }
38129 return resultobj;
38130 fail:
38131 return NULL;
38132 }
38133
38134
38135 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38136 PyObject *resultobj = 0;
38137 wxWindow *arg1 = (wxWindow *) 0 ;
38138 void *argp1 = 0 ;
38139 int res1 = 0 ;
38140 PyObject *swig_obj[1] ;
38141
38142 if (!args) SWIG_fail;
38143 swig_obj[0] = args;
38144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38145 if (!SWIG_IsOK(res1)) {
38146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
38147 }
38148 arg1 = reinterpret_cast< wxWindow * >(argp1);
38149 {
38150 PyThreadState* __tstate = wxPyBeginAllowThreads();
38151 (arg1)->Thaw();
38152 wxPyEndAllowThreads(__tstate);
38153 if (PyErr_Occurred()) SWIG_fail;
38154 }
38155 resultobj = SWIG_Py_Void();
38156 return resultobj;
38157 fail:
38158 return NULL;
38159 }
38160
38161
38162 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38163 PyObject *resultobj = 0;
38164 wxWindow *arg1 = (wxWindow *) 0 ;
38165 wxDC *arg2 = 0 ;
38166 void *argp1 = 0 ;
38167 int res1 = 0 ;
38168 void *argp2 = 0 ;
38169 int res2 = 0 ;
38170 PyObject * obj0 = 0 ;
38171 PyObject * obj1 = 0 ;
38172 char * kwnames[] = {
38173 (char *) "self",(char *) "dc", NULL
38174 };
38175
38176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
38177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38178 if (!SWIG_IsOK(res1)) {
38179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
38180 }
38181 arg1 = reinterpret_cast< wxWindow * >(argp1);
38182 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
38183 if (!SWIG_IsOK(res2)) {
38184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38185 }
38186 if (!argp2) {
38187 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38188 }
38189 arg2 = reinterpret_cast< wxDC * >(argp2);
38190 {
38191 PyThreadState* __tstate = wxPyBeginAllowThreads();
38192 (arg1)->PrepareDC(*arg2);
38193 wxPyEndAllowThreads(__tstate);
38194 if (PyErr_Occurred()) SWIG_fail;
38195 }
38196 resultobj = SWIG_Py_Void();
38197 return resultobj;
38198 fail:
38199 return NULL;
38200 }
38201
38202
38203 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38204 PyObject *resultobj = 0;
38205 wxWindow *arg1 = (wxWindow *) 0 ;
38206 bool result;
38207 void *argp1 = 0 ;
38208 int res1 = 0 ;
38209 PyObject *swig_obj[1] ;
38210
38211 if (!args) SWIG_fail;
38212 swig_obj[0] = args;
38213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38214 if (!SWIG_IsOK(res1)) {
38215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
38216 }
38217 arg1 = reinterpret_cast< wxWindow * >(argp1);
38218 {
38219 PyThreadState* __tstate = wxPyBeginAllowThreads();
38220 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
38221 wxPyEndAllowThreads(__tstate);
38222 if (PyErr_Occurred()) SWIG_fail;
38223 }
38224 {
38225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38226 }
38227 return resultobj;
38228 fail:
38229 return NULL;
38230 }
38231
38232
38233 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38234 PyObject *resultobj = 0;
38235 wxWindow *arg1 = (wxWindow *) 0 ;
38236 wxRegion *result = 0 ;
38237 void *argp1 = 0 ;
38238 int res1 = 0 ;
38239 PyObject *swig_obj[1] ;
38240
38241 if (!args) SWIG_fail;
38242 swig_obj[0] = args;
38243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38244 if (!SWIG_IsOK(res1)) {
38245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
38246 }
38247 arg1 = reinterpret_cast< wxWindow * >(argp1);
38248 {
38249 PyThreadState* __tstate = wxPyBeginAllowThreads();
38250 {
38251 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
38252 result = (wxRegion *) &_result_ref;
38253 }
38254 wxPyEndAllowThreads(__tstate);
38255 if (PyErr_Occurred()) SWIG_fail;
38256 }
38257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
38258 return resultobj;
38259 fail:
38260 return NULL;
38261 }
38262
38263
38264 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38265 PyObject *resultobj = 0;
38266 wxWindow *arg1 = (wxWindow *) 0 ;
38267 wxRect result;
38268 void *argp1 = 0 ;
38269 int res1 = 0 ;
38270 PyObject *swig_obj[1] ;
38271
38272 if (!args) SWIG_fail;
38273 swig_obj[0] = args;
38274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38275 if (!SWIG_IsOK(res1)) {
38276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38277 }
38278 arg1 = reinterpret_cast< wxWindow * >(argp1);
38279 {
38280 PyThreadState* __tstate = wxPyBeginAllowThreads();
38281 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
38282 wxPyEndAllowThreads(__tstate);
38283 if (PyErr_Occurred()) SWIG_fail;
38284 }
38285 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
38286 return resultobj;
38287 fail:
38288 return NULL;
38289 }
38290
38291
38292 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38293 PyObject *resultobj = 0;
38294 wxWindow *arg1 = (wxWindow *) 0 ;
38295 int arg2 ;
38296 int arg3 ;
38297 int arg4 = (int) 1 ;
38298 int arg5 = (int) 1 ;
38299 bool result;
38300 void *argp1 = 0 ;
38301 int res1 = 0 ;
38302 int val2 ;
38303 int ecode2 = 0 ;
38304 int val3 ;
38305 int ecode3 = 0 ;
38306 int val4 ;
38307 int ecode4 = 0 ;
38308 int val5 ;
38309 int ecode5 = 0 ;
38310 PyObject * obj0 = 0 ;
38311 PyObject * obj1 = 0 ;
38312 PyObject * obj2 = 0 ;
38313 PyObject * obj3 = 0 ;
38314 PyObject * obj4 = 0 ;
38315 char * kwnames[] = {
38316 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
38317 };
38318
38319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38321 if (!SWIG_IsOK(res1)) {
38322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
38323 }
38324 arg1 = reinterpret_cast< wxWindow * >(argp1);
38325 ecode2 = SWIG_AsVal_int(obj1, &val2);
38326 if (!SWIG_IsOK(ecode2)) {
38327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
38328 }
38329 arg2 = static_cast< int >(val2);
38330 ecode3 = SWIG_AsVal_int(obj2, &val3);
38331 if (!SWIG_IsOK(ecode3)) {
38332 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
38333 }
38334 arg3 = static_cast< int >(val3);
38335 if (obj3) {
38336 ecode4 = SWIG_AsVal_int(obj3, &val4);
38337 if (!SWIG_IsOK(ecode4)) {
38338 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
38339 }
38340 arg4 = static_cast< int >(val4);
38341 }
38342 if (obj4) {
38343 ecode5 = SWIG_AsVal_int(obj4, &val5);
38344 if (!SWIG_IsOK(ecode5)) {
38345 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38346 }
38347 arg5 = static_cast< int >(val5);
38348 }
38349 {
38350 PyThreadState* __tstate = wxPyBeginAllowThreads();
38351 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38352 wxPyEndAllowThreads(__tstate);
38353 if (PyErr_Occurred()) SWIG_fail;
38354 }
38355 {
38356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38357 }
38358 return resultobj;
38359 fail:
38360 return NULL;
38361 }
38362
38363
38364 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38365 PyObject *resultobj = 0;
38366 wxWindow *arg1 = (wxWindow *) 0 ;
38367 wxPoint *arg2 = 0 ;
38368 bool result;
38369 void *argp1 = 0 ;
38370 int res1 = 0 ;
38371 wxPoint temp2 ;
38372 PyObject * obj0 = 0 ;
38373 PyObject * obj1 = 0 ;
38374 char * kwnames[] = {
38375 (char *) "self",(char *) "pt", NULL
38376 };
38377
38378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38380 if (!SWIG_IsOK(res1)) {
38381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38382 }
38383 arg1 = reinterpret_cast< wxWindow * >(argp1);
38384 {
38385 arg2 = &temp2;
38386 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38387 }
38388 {
38389 PyThreadState* __tstate = wxPyBeginAllowThreads();
38390 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38391 wxPyEndAllowThreads(__tstate);
38392 if (PyErr_Occurred()) SWIG_fail;
38393 }
38394 {
38395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38396 }
38397 return resultobj;
38398 fail:
38399 return NULL;
38400 }
38401
38402
38403 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38404 PyObject *resultobj = 0;
38405 wxWindow *arg1 = (wxWindow *) 0 ;
38406 wxRect *arg2 = 0 ;
38407 bool result;
38408 void *argp1 = 0 ;
38409 int res1 = 0 ;
38410 wxRect temp2 ;
38411 PyObject * obj0 = 0 ;
38412 PyObject * obj1 = 0 ;
38413 char * kwnames[] = {
38414 (char *) "self",(char *) "rect", NULL
38415 };
38416
38417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38419 if (!SWIG_IsOK(res1)) {
38420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38421 }
38422 arg1 = reinterpret_cast< wxWindow * >(argp1);
38423 {
38424 arg2 = &temp2;
38425 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38426 }
38427 {
38428 PyThreadState* __tstate = wxPyBeginAllowThreads();
38429 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38430 wxPyEndAllowThreads(__tstate);
38431 if (PyErr_Occurred()) SWIG_fail;
38432 }
38433 {
38434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38435 }
38436 return resultobj;
38437 fail:
38438 return NULL;
38439 }
38440
38441
38442 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38443 PyObject *resultobj = 0;
38444 wxWindow *arg1 = (wxWindow *) 0 ;
38445 SwigValueWrapper<wxVisualAttributes > 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_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38455 }
38456 arg1 = reinterpret_cast< wxWindow * >(argp1);
38457 {
38458 PyThreadState* __tstate = wxPyBeginAllowThreads();
38459 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38460 wxPyEndAllowThreads(__tstate);
38461 if (PyErr_Occurred()) SWIG_fail;
38462 }
38463 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38464 return resultobj;
38465 fail:
38466 return NULL;
38467 }
38468
38469
38470 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38471 PyObject *resultobj = 0;
38472 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38473 SwigValueWrapper<wxVisualAttributes > result;
38474 int val1 ;
38475 int ecode1 = 0 ;
38476 PyObject * obj0 = 0 ;
38477 char * kwnames[] = {
38478 (char *) "variant", NULL
38479 };
38480
38481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38482 if (obj0) {
38483 ecode1 = SWIG_AsVal_int(obj0, &val1);
38484 if (!SWIG_IsOK(ecode1)) {
38485 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38486 }
38487 arg1 = static_cast< wxWindowVariant >(val1);
38488 }
38489 {
38490 if (!wxPyCheckForApp()) SWIG_fail;
38491 PyThreadState* __tstate = wxPyBeginAllowThreads();
38492 result = wxWindow::GetClassDefaultAttributes(arg1);
38493 wxPyEndAllowThreads(__tstate);
38494 if (PyErr_Occurred()) SWIG_fail;
38495 }
38496 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38497 return resultobj;
38498 fail:
38499 return NULL;
38500 }
38501
38502
38503 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38504 PyObject *resultobj = 0;
38505 wxWindow *arg1 = (wxWindow *) 0 ;
38506 wxColour *arg2 = 0 ;
38507 bool result;
38508 void *argp1 = 0 ;
38509 int res1 = 0 ;
38510 wxColour temp2 ;
38511 PyObject * obj0 = 0 ;
38512 PyObject * obj1 = 0 ;
38513 char * kwnames[] = {
38514 (char *) "self",(char *) "colour", NULL
38515 };
38516
38517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38519 if (!SWIG_IsOK(res1)) {
38520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38521 }
38522 arg1 = reinterpret_cast< wxWindow * >(argp1);
38523 {
38524 arg2 = &temp2;
38525 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38526 }
38527 {
38528 PyThreadState* __tstate = wxPyBeginAllowThreads();
38529 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38530 wxPyEndAllowThreads(__tstate);
38531 if (PyErr_Occurred()) SWIG_fail;
38532 }
38533 {
38534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38535 }
38536 return resultobj;
38537 fail:
38538 return NULL;
38539 }
38540
38541
38542 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38543 PyObject *resultobj = 0;
38544 wxWindow *arg1 = (wxWindow *) 0 ;
38545 wxColour *arg2 = 0 ;
38546 void *argp1 = 0 ;
38547 int res1 = 0 ;
38548 wxColour temp2 ;
38549 PyObject * obj0 = 0 ;
38550 PyObject * obj1 = 0 ;
38551 char * kwnames[] = {
38552 (char *) "self",(char *) "colour", NULL
38553 };
38554
38555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38557 if (!SWIG_IsOK(res1)) {
38558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38559 }
38560 arg1 = reinterpret_cast< wxWindow * >(argp1);
38561 {
38562 arg2 = &temp2;
38563 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38564 }
38565 {
38566 PyThreadState* __tstate = wxPyBeginAllowThreads();
38567 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38568 wxPyEndAllowThreads(__tstate);
38569 if (PyErr_Occurred()) SWIG_fail;
38570 }
38571 resultobj = SWIG_Py_Void();
38572 return resultobj;
38573 fail:
38574 return NULL;
38575 }
38576
38577
38578 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38579 PyObject *resultobj = 0;
38580 wxWindow *arg1 = (wxWindow *) 0 ;
38581 wxColour *arg2 = 0 ;
38582 bool result;
38583 void *argp1 = 0 ;
38584 int res1 = 0 ;
38585 wxColour temp2 ;
38586 PyObject * obj0 = 0 ;
38587 PyObject * obj1 = 0 ;
38588 char * kwnames[] = {
38589 (char *) "self",(char *) "colour", NULL
38590 };
38591
38592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38594 if (!SWIG_IsOK(res1)) {
38595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38596 }
38597 arg1 = reinterpret_cast< wxWindow * >(argp1);
38598 {
38599 arg2 = &temp2;
38600 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38601 }
38602 {
38603 PyThreadState* __tstate = wxPyBeginAllowThreads();
38604 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38605 wxPyEndAllowThreads(__tstate);
38606 if (PyErr_Occurred()) SWIG_fail;
38607 }
38608 {
38609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38610 }
38611 return resultobj;
38612 fail:
38613 return NULL;
38614 }
38615
38616
38617 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38618 PyObject *resultobj = 0;
38619 wxWindow *arg1 = (wxWindow *) 0 ;
38620 wxColour *arg2 = 0 ;
38621 void *argp1 = 0 ;
38622 int res1 = 0 ;
38623 wxColour temp2 ;
38624 PyObject * obj0 = 0 ;
38625 PyObject * obj1 = 0 ;
38626 char * kwnames[] = {
38627 (char *) "self",(char *) "colour", NULL
38628 };
38629
38630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38632 if (!SWIG_IsOK(res1)) {
38633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38634 }
38635 arg1 = reinterpret_cast< wxWindow * >(argp1);
38636 {
38637 arg2 = &temp2;
38638 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38639 }
38640 {
38641 PyThreadState* __tstate = wxPyBeginAllowThreads();
38642 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38643 wxPyEndAllowThreads(__tstate);
38644 if (PyErr_Occurred()) SWIG_fail;
38645 }
38646 resultobj = SWIG_Py_Void();
38647 return resultobj;
38648 fail:
38649 return NULL;
38650 }
38651
38652
38653 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38654 PyObject *resultobj = 0;
38655 wxWindow *arg1 = (wxWindow *) 0 ;
38656 wxColour result;
38657 void *argp1 = 0 ;
38658 int res1 = 0 ;
38659 PyObject *swig_obj[1] ;
38660
38661 if (!args) SWIG_fail;
38662 swig_obj[0] = args;
38663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38664 if (!SWIG_IsOK(res1)) {
38665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38666 }
38667 arg1 = reinterpret_cast< wxWindow * >(argp1);
38668 {
38669 PyThreadState* __tstate = wxPyBeginAllowThreads();
38670 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38671 wxPyEndAllowThreads(__tstate);
38672 if (PyErr_Occurred()) SWIG_fail;
38673 }
38674 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38675 return resultobj;
38676 fail:
38677 return NULL;
38678 }
38679
38680
38681 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38682 PyObject *resultobj = 0;
38683 wxWindow *arg1 = (wxWindow *) 0 ;
38684 wxColour result;
38685 void *argp1 = 0 ;
38686 int res1 = 0 ;
38687 PyObject *swig_obj[1] ;
38688
38689 if (!args) SWIG_fail;
38690 swig_obj[0] = args;
38691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38692 if (!SWIG_IsOK(res1)) {
38693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38694 }
38695 arg1 = reinterpret_cast< wxWindow * >(argp1);
38696 {
38697 PyThreadState* __tstate = wxPyBeginAllowThreads();
38698 result = ((wxWindow const *)arg1)->GetForegroundColour();
38699 wxPyEndAllowThreads(__tstate);
38700 if (PyErr_Occurred()) SWIG_fail;
38701 }
38702 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38703 return resultobj;
38704 fail:
38705 return NULL;
38706 }
38707
38708
38709 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38710 PyObject *resultobj = 0;
38711 wxWindow *arg1 = (wxWindow *) 0 ;
38712 bool result;
38713 void *argp1 = 0 ;
38714 int res1 = 0 ;
38715 PyObject *swig_obj[1] ;
38716
38717 if (!args) SWIG_fail;
38718 swig_obj[0] = args;
38719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38720 if (!SWIG_IsOK(res1)) {
38721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38722 }
38723 arg1 = reinterpret_cast< wxWindow * >(argp1);
38724 {
38725 PyThreadState* __tstate = wxPyBeginAllowThreads();
38726 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38727 wxPyEndAllowThreads(__tstate);
38728 if (PyErr_Occurred()) SWIG_fail;
38729 }
38730 {
38731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38732 }
38733 return resultobj;
38734 fail:
38735 return NULL;
38736 }
38737
38738
38739 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38740 PyObject *resultobj = 0;
38741 wxWindow *arg1 = (wxWindow *) 0 ;
38742 bool result;
38743 void *argp1 = 0 ;
38744 int res1 = 0 ;
38745 PyObject *swig_obj[1] ;
38746
38747 if (!args) SWIG_fail;
38748 swig_obj[0] = args;
38749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38750 if (!SWIG_IsOK(res1)) {
38751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38752 }
38753 arg1 = reinterpret_cast< wxWindow * >(argp1);
38754 {
38755 PyThreadState* __tstate = wxPyBeginAllowThreads();
38756 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38757 wxPyEndAllowThreads(__tstate);
38758 if (PyErr_Occurred()) SWIG_fail;
38759 }
38760 {
38761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38762 }
38763 return resultobj;
38764 fail:
38765 return NULL;
38766 }
38767
38768
38769 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38770 PyObject *resultobj = 0;
38771 wxWindow *arg1 = (wxWindow *) 0 ;
38772 wxBackgroundStyle arg2 ;
38773 bool result;
38774 void *argp1 = 0 ;
38775 int res1 = 0 ;
38776 int val2 ;
38777 int ecode2 = 0 ;
38778 PyObject * obj0 = 0 ;
38779 PyObject * obj1 = 0 ;
38780 char * kwnames[] = {
38781 (char *) "self",(char *) "style", NULL
38782 };
38783
38784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38786 if (!SWIG_IsOK(res1)) {
38787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38788 }
38789 arg1 = reinterpret_cast< wxWindow * >(argp1);
38790 ecode2 = SWIG_AsVal_int(obj1, &val2);
38791 if (!SWIG_IsOK(ecode2)) {
38792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38793 }
38794 arg2 = static_cast< wxBackgroundStyle >(val2);
38795 {
38796 PyThreadState* __tstate = wxPyBeginAllowThreads();
38797 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38798 wxPyEndAllowThreads(__tstate);
38799 if (PyErr_Occurred()) SWIG_fail;
38800 }
38801 {
38802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38803 }
38804 return resultobj;
38805 fail:
38806 return NULL;
38807 }
38808
38809
38810 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38811 PyObject *resultobj = 0;
38812 wxWindow *arg1 = (wxWindow *) 0 ;
38813 wxBackgroundStyle result;
38814 void *argp1 = 0 ;
38815 int res1 = 0 ;
38816 PyObject *swig_obj[1] ;
38817
38818 if (!args) SWIG_fail;
38819 swig_obj[0] = args;
38820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38821 if (!SWIG_IsOK(res1)) {
38822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38823 }
38824 arg1 = reinterpret_cast< wxWindow * >(argp1);
38825 {
38826 PyThreadState* __tstate = wxPyBeginAllowThreads();
38827 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38828 wxPyEndAllowThreads(__tstate);
38829 if (PyErr_Occurred()) SWIG_fail;
38830 }
38831 resultobj = SWIG_From_int(static_cast< int >(result));
38832 return resultobj;
38833 fail:
38834 return NULL;
38835 }
38836
38837
38838 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38839 PyObject *resultobj = 0;
38840 wxWindow *arg1 = (wxWindow *) 0 ;
38841 bool result;
38842 void *argp1 = 0 ;
38843 int res1 = 0 ;
38844 PyObject *swig_obj[1] ;
38845
38846 if (!args) SWIG_fail;
38847 swig_obj[0] = args;
38848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38849 if (!SWIG_IsOK(res1)) {
38850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38851 }
38852 arg1 = reinterpret_cast< wxWindow * >(argp1);
38853 {
38854 PyThreadState* __tstate = wxPyBeginAllowThreads();
38855 result = (bool)(arg1)->HasTransparentBackground();
38856 wxPyEndAllowThreads(__tstate);
38857 if (PyErr_Occurred()) SWIG_fail;
38858 }
38859 {
38860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38861 }
38862 return resultobj;
38863 fail:
38864 return NULL;
38865 }
38866
38867
38868 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38869 PyObject *resultobj = 0;
38870 wxWindow *arg1 = (wxWindow *) 0 ;
38871 wxCursor *arg2 = 0 ;
38872 bool result;
38873 void *argp1 = 0 ;
38874 int res1 = 0 ;
38875 void *argp2 = 0 ;
38876 int res2 = 0 ;
38877 PyObject * obj0 = 0 ;
38878 PyObject * obj1 = 0 ;
38879 char * kwnames[] = {
38880 (char *) "self",(char *) "cursor", NULL
38881 };
38882
38883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38885 if (!SWIG_IsOK(res1)) {
38886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38887 }
38888 arg1 = reinterpret_cast< wxWindow * >(argp1);
38889 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38890 if (!SWIG_IsOK(res2)) {
38891 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38892 }
38893 if (!argp2) {
38894 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38895 }
38896 arg2 = reinterpret_cast< wxCursor * >(argp2);
38897 {
38898 PyThreadState* __tstate = wxPyBeginAllowThreads();
38899 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38900 wxPyEndAllowThreads(__tstate);
38901 if (PyErr_Occurred()) SWIG_fail;
38902 }
38903 {
38904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38905 }
38906 return resultobj;
38907 fail:
38908 return NULL;
38909 }
38910
38911
38912 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38913 PyObject *resultobj = 0;
38914 wxWindow *arg1 = (wxWindow *) 0 ;
38915 wxCursor result;
38916 void *argp1 = 0 ;
38917 int res1 = 0 ;
38918 PyObject *swig_obj[1] ;
38919
38920 if (!args) SWIG_fail;
38921 swig_obj[0] = args;
38922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38923 if (!SWIG_IsOK(res1)) {
38924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38925 }
38926 arg1 = reinterpret_cast< wxWindow * >(argp1);
38927 {
38928 PyThreadState* __tstate = wxPyBeginAllowThreads();
38929 result = (arg1)->GetCursor();
38930 wxPyEndAllowThreads(__tstate);
38931 if (PyErr_Occurred()) SWIG_fail;
38932 }
38933 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38934 return resultobj;
38935 fail:
38936 return NULL;
38937 }
38938
38939
38940 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38941 PyObject *resultobj = 0;
38942 wxWindow *arg1 = (wxWindow *) 0 ;
38943 wxFont *arg2 = 0 ;
38944 bool result;
38945 void *argp1 = 0 ;
38946 int res1 = 0 ;
38947 void *argp2 = 0 ;
38948 int res2 = 0 ;
38949 PyObject * obj0 = 0 ;
38950 PyObject * obj1 = 0 ;
38951 char * kwnames[] = {
38952 (char *) "self",(char *) "font", NULL
38953 };
38954
38955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38957 if (!SWIG_IsOK(res1)) {
38958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38959 }
38960 arg1 = reinterpret_cast< wxWindow * >(argp1);
38961 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38962 if (!SWIG_IsOK(res2)) {
38963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38964 }
38965 if (!argp2) {
38966 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38967 }
38968 arg2 = reinterpret_cast< wxFont * >(argp2);
38969 {
38970 PyThreadState* __tstate = wxPyBeginAllowThreads();
38971 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38972 wxPyEndAllowThreads(__tstate);
38973 if (PyErr_Occurred()) SWIG_fail;
38974 }
38975 {
38976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38977 }
38978 return resultobj;
38979 fail:
38980 return NULL;
38981 }
38982
38983
38984 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38985 PyObject *resultobj = 0;
38986 wxWindow *arg1 = (wxWindow *) 0 ;
38987 wxFont *arg2 = 0 ;
38988 void *argp1 = 0 ;
38989 int res1 = 0 ;
38990 void *argp2 = 0 ;
38991 int res2 = 0 ;
38992 PyObject * obj0 = 0 ;
38993 PyObject * obj1 = 0 ;
38994 char * kwnames[] = {
38995 (char *) "self",(char *) "font", NULL
38996 };
38997
38998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39000 if (!SWIG_IsOK(res1)) {
39001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39002 }
39003 arg1 = reinterpret_cast< wxWindow * >(argp1);
39004 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
39005 if (!SWIG_IsOK(res2)) {
39006 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39007 }
39008 if (!argp2) {
39009 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39010 }
39011 arg2 = reinterpret_cast< wxFont * >(argp2);
39012 {
39013 PyThreadState* __tstate = wxPyBeginAllowThreads();
39014 (arg1)->SetOwnFont((wxFont const &)*arg2);
39015 wxPyEndAllowThreads(__tstate);
39016 if (PyErr_Occurred()) SWIG_fail;
39017 }
39018 resultobj = SWIG_Py_Void();
39019 return resultobj;
39020 fail:
39021 return NULL;
39022 }
39023
39024
39025 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39026 PyObject *resultobj = 0;
39027 wxWindow *arg1 = (wxWindow *) 0 ;
39028 wxFont result;
39029 void *argp1 = 0 ;
39030 int res1 = 0 ;
39031 PyObject *swig_obj[1] ;
39032
39033 if (!args) SWIG_fail;
39034 swig_obj[0] = args;
39035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39036 if (!SWIG_IsOK(res1)) {
39037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39038 }
39039 arg1 = reinterpret_cast< wxWindow * >(argp1);
39040 {
39041 PyThreadState* __tstate = wxPyBeginAllowThreads();
39042 result = (arg1)->GetFont();
39043 wxPyEndAllowThreads(__tstate);
39044 if (PyErr_Occurred()) SWIG_fail;
39045 }
39046 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
39047 return resultobj;
39048 fail:
39049 return NULL;
39050 }
39051
39052
39053 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39054 PyObject *resultobj = 0;
39055 wxWindow *arg1 = (wxWindow *) 0 ;
39056 wxCaret *arg2 = (wxCaret *) 0 ;
39057 void *argp1 = 0 ;
39058 int res1 = 0 ;
39059 int res2 = 0 ;
39060 PyObject * obj0 = 0 ;
39061 PyObject * obj1 = 0 ;
39062 char * kwnames[] = {
39063 (char *) "self",(char *) "caret", NULL
39064 };
39065
39066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
39067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39068 if (!SWIG_IsOK(res1)) {
39069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
39070 }
39071 arg1 = reinterpret_cast< wxWindow * >(argp1);
39072 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
39073 if (!SWIG_IsOK(res2)) {
39074 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
39075 }
39076 {
39077 PyThreadState* __tstate = wxPyBeginAllowThreads();
39078 (arg1)->SetCaret(arg2);
39079 wxPyEndAllowThreads(__tstate);
39080 if (PyErr_Occurred()) SWIG_fail;
39081 }
39082 resultobj = SWIG_Py_Void();
39083 return resultobj;
39084 fail:
39085 return NULL;
39086 }
39087
39088
39089 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39090 PyObject *resultobj = 0;
39091 wxWindow *arg1 = (wxWindow *) 0 ;
39092 wxCaret *result = 0 ;
39093 void *argp1 = 0 ;
39094 int res1 = 0 ;
39095 PyObject *swig_obj[1] ;
39096
39097 if (!args) SWIG_fail;
39098 swig_obj[0] = args;
39099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39100 if (!SWIG_IsOK(res1)) {
39101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
39102 }
39103 arg1 = reinterpret_cast< wxWindow * >(argp1);
39104 {
39105 PyThreadState* __tstate = wxPyBeginAllowThreads();
39106 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
39107 wxPyEndAllowThreads(__tstate);
39108 if (PyErr_Occurred()) SWIG_fail;
39109 }
39110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
39111 return resultobj;
39112 fail:
39113 return NULL;
39114 }
39115
39116
39117 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39118 PyObject *resultobj = 0;
39119 wxWindow *arg1 = (wxWindow *) 0 ;
39120 int result;
39121 void *argp1 = 0 ;
39122 int res1 = 0 ;
39123 PyObject *swig_obj[1] ;
39124
39125 if (!args) SWIG_fail;
39126 swig_obj[0] = args;
39127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39128 if (!SWIG_IsOK(res1)) {
39129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
39130 }
39131 arg1 = reinterpret_cast< wxWindow * >(argp1);
39132 {
39133 PyThreadState* __tstate = wxPyBeginAllowThreads();
39134 result = (int)((wxWindow const *)arg1)->GetCharHeight();
39135 wxPyEndAllowThreads(__tstate);
39136 if (PyErr_Occurred()) SWIG_fail;
39137 }
39138 resultobj = SWIG_From_int(static_cast< int >(result));
39139 return resultobj;
39140 fail:
39141 return NULL;
39142 }
39143
39144
39145 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39146 PyObject *resultobj = 0;
39147 wxWindow *arg1 = (wxWindow *) 0 ;
39148 int result;
39149 void *argp1 = 0 ;
39150 int res1 = 0 ;
39151 PyObject *swig_obj[1] ;
39152
39153 if (!args) SWIG_fail;
39154 swig_obj[0] = args;
39155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39156 if (!SWIG_IsOK(res1)) {
39157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
39158 }
39159 arg1 = reinterpret_cast< wxWindow * >(argp1);
39160 {
39161 PyThreadState* __tstate = wxPyBeginAllowThreads();
39162 result = (int)((wxWindow const *)arg1)->GetCharWidth();
39163 wxPyEndAllowThreads(__tstate);
39164 if (PyErr_Occurred()) SWIG_fail;
39165 }
39166 resultobj = SWIG_From_int(static_cast< int >(result));
39167 return resultobj;
39168 fail:
39169 return NULL;
39170 }
39171
39172
39173 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39174 PyObject *resultobj = 0;
39175 wxWindow *arg1 = (wxWindow *) 0 ;
39176 wxString *arg2 = 0 ;
39177 int *arg3 = (int *) 0 ;
39178 int *arg4 = (int *) 0 ;
39179 void *argp1 = 0 ;
39180 int res1 = 0 ;
39181 bool temp2 = false ;
39182 int temp3 ;
39183 int res3 = SWIG_TMPOBJ ;
39184 int temp4 ;
39185 int res4 = SWIG_TMPOBJ ;
39186 PyObject * obj0 = 0 ;
39187 PyObject * obj1 = 0 ;
39188 char * kwnames[] = {
39189 (char *) "self",(char *) "string", NULL
39190 };
39191
39192 arg3 = &temp3;
39193 arg4 = &temp4;
39194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
39195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39196 if (!SWIG_IsOK(res1)) {
39197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39198 }
39199 arg1 = reinterpret_cast< wxWindow * >(argp1);
39200 {
39201 arg2 = wxString_in_helper(obj1);
39202 if (arg2 == NULL) SWIG_fail;
39203 temp2 = true;
39204 }
39205 {
39206 PyThreadState* __tstate = wxPyBeginAllowThreads();
39207 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
39208 wxPyEndAllowThreads(__tstate);
39209 if (PyErr_Occurred()) SWIG_fail;
39210 }
39211 resultobj = SWIG_Py_Void();
39212 if (SWIG_IsTmpObj(res3)) {
39213 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39214 } else {
39215 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39216 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39217 }
39218 if (SWIG_IsTmpObj(res4)) {
39219 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39220 } else {
39221 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39222 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39223 }
39224 {
39225 if (temp2)
39226 delete arg2;
39227 }
39228 return resultobj;
39229 fail:
39230 {
39231 if (temp2)
39232 delete arg2;
39233 }
39234 return NULL;
39235 }
39236
39237
39238 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39239 PyObject *resultobj = 0;
39240 wxWindow *arg1 = (wxWindow *) 0 ;
39241 wxString *arg2 = 0 ;
39242 int *arg3 = (int *) 0 ;
39243 int *arg4 = (int *) 0 ;
39244 int *arg5 = (int *) 0 ;
39245 int *arg6 = (int *) 0 ;
39246 wxFont *arg7 = (wxFont *) NULL ;
39247 void *argp1 = 0 ;
39248 int res1 = 0 ;
39249 bool temp2 = false ;
39250 int temp3 ;
39251 int res3 = SWIG_TMPOBJ ;
39252 int temp4 ;
39253 int res4 = SWIG_TMPOBJ ;
39254 int temp5 ;
39255 int res5 = SWIG_TMPOBJ ;
39256 int temp6 ;
39257 int res6 = SWIG_TMPOBJ ;
39258 void *argp7 = 0 ;
39259 int res7 = 0 ;
39260 PyObject * obj0 = 0 ;
39261 PyObject * obj1 = 0 ;
39262 PyObject * obj2 = 0 ;
39263 char * kwnames[] = {
39264 (char *) "self",(char *) "string",(char *) "font", NULL
39265 };
39266
39267 arg3 = &temp3;
39268 arg4 = &temp4;
39269 arg5 = &temp5;
39270 arg6 = &temp6;
39271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39273 if (!SWIG_IsOK(res1)) {
39274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39275 }
39276 arg1 = reinterpret_cast< wxWindow * >(argp1);
39277 {
39278 arg2 = wxString_in_helper(obj1);
39279 if (arg2 == NULL) SWIG_fail;
39280 temp2 = true;
39281 }
39282 if (obj2) {
39283 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
39284 if (!SWIG_IsOK(res7)) {
39285 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
39286 }
39287 arg7 = reinterpret_cast< wxFont * >(argp7);
39288 }
39289 {
39290 PyThreadState* __tstate = wxPyBeginAllowThreads();
39291 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
39292 wxPyEndAllowThreads(__tstate);
39293 if (PyErr_Occurred()) SWIG_fail;
39294 }
39295 resultobj = SWIG_Py_Void();
39296 if (SWIG_IsTmpObj(res3)) {
39297 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39298 } else {
39299 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39300 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39301 }
39302 if (SWIG_IsTmpObj(res4)) {
39303 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39304 } else {
39305 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39306 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39307 }
39308 if (SWIG_IsTmpObj(res5)) {
39309 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
39310 } else {
39311 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39312 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
39313 }
39314 if (SWIG_IsTmpObj(res6)) {
39315 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
39316 } else {
39317 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39318 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
39319 }
39320 {
39321 if (temp2)
39322 delete arg2;
39323 }
39324 return resultobj;
39325 fail:
39326 {
39327 if (temp2)
39328 delete arg2;
39329 }
39330 return NULL;
39331 }
39332
39333
39334 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39335 PyObject *resultobj = 0;
39336 wxWindow *arg1 = (wxWindow *) 0 ;
39337 int *arg2 = (int *) 0 ;
39338 int *arg3 = (int *) 0 ;
39339 void *argp1 = 0 ;
39340 int res1 = 0 ;
39341 int temp2 ;
39342 int res2 = 0 ;
39343 int temp3 ;
39344 int res3 = 0 ;
39345 PyObject * obj0 = 0 ;
39346 PyObject * obj1 = 0 ;
39347 PyObject * obj2 = 0 ;
39348 char * kwnames[] = {
39349 (char *) "self",(char *) "x",(char *) "y", NULL
39350 };
39351
39352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39354 if (!SWIG_IsOK(res1)) {
39355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39356 }
39357 arg1 = reinterpret_cast< wxWindow * >(argp1);
39358 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39359 int val;
39360 int ecode = SWIG_AsVal_int(obj1, &val);
39361 if (!SWIG_IsOK(ecode)) {
39362 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39363 }
39364 temp2 = static_cast< int >(val);
39365 arg2 = &temp2;
39366 res2 = SWIG_AddTmpMask(ecode);
39367 }
39368 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39369 int val;
39370 int ecode = SWIG_AsVal_int(obj2, &val);
39371 if (!SWIG_IsOK(ecode)) {
39372 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39373 }
39374 temp3 = static_cast< int >(val);
39375 arg3 = &temp3;
39376 res3 = SWIG_AddTmpMask(ecode);
39377 }
39378 {
39379 PyThreadState* __tstate = wxPyBeginAllowThreads();
39380 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39381 wxPyEndAllowThreads(__tstate);
39382 if (PyErr_Occurred()) SWIG_fail;
39383 }
39384 resultobj = SWIG_Py_Void();
39385 if (SWIG_IsTmpObj(res2)) {
39386 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39387 } else {
39388 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39389 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39390 }
39391 if (SWIG_IsTmpObj(res3)) {
39392 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39393 } else {
39394 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39395 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39396 }
39397 return resultobj;
39398 fail:
39399 return NULL;
39400 }
39401
39402
39403 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39404 PyObject *resultobj = 0;
39405 wxWindow *arg1 = (wxWindow *) 0 ;
39406 int *arg2 = (int *) 0 ;
39407 int *arg3 = (int *) 0 ;
39408 void *argp1 = 0 ;
39409 int res1 = 0 ;
39410 int temp2 ;
39411 int res2 = 0 ;
39412 int temp3 ;
39413 int res3 = 0 ;
39414 PyObject * obj0 = 0 ;
39415 PyObject * obj1 = 0 ;
39416 PyObject * obj2 = 0 ;
39417 char * kwnames[] = {
39418 (char *) "self",(char *) "x",(char *) "y", NULL
39419 };
39420
39421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39423 if (!SWIG_IsOK(res1)) {
39424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39425 }
39426 arg1 = reinterpret_cast< wxWindow * >(argp1);
39427 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39428 int val;
39429 int ecode = SWIG_AsVal_int(obj1, &val);
39430 if (!SWIG_IsOK(ecode)) {
39431 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39432 }
39433 temp2 = static_cast< int >(val);
39434 arg2 = &temp2;
39435 res2 = SWIG_AddTmpMask(ecode);
39436 }
39437 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39438 int val;
39439 int ecode = SWIG_AsVal_int(obj2, &val);
39440 if (!SWIG_IsOK(ecode)) {
39441 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39442 }
39443 temp3 = static_cast< int >(val);
39444 arg3 = &temp3;
39445 res3 = SWIG_AddTmpMask(ecode);
39446 }
39447 {
39448 PyThreadState* __tstate = wxPyBeginAllowThreads();
39449 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39450 wxPyEndAllowThreads(__tstate);
39451 if (PyErr_Occurred()) SWIG_fail;
39452 }
39453 resultobj = SWIG_Py_Void();
39454 if (SWIG_IsTmpObj(res2)) {
39455 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39456 } else {
39457 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39458 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39459 }
39460 if (SWIG_IsTmpObj(res3)) {
39461 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39462 } else {
39463 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39464 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39465 }
39466 return resultobj;
39467 fail:
39468 return NULL;
39469 }
39470
39471
39472 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39473 PyObject *resultobj = 0;
39474 wxWindow *arg1 = (wxWindow *) 0 ;
39475 wxPoint *arg2 = 0 ;
39476 wxPoint result;
39477 void *argp1 = 0 ;
39478 int res1 = 0 ;
39479 wxPoint temp2 ;
39480 PyObject * obj0 = 0 ;
39481 PyObject * obj1 = 0 ;
39482 char * kwnames[] = {
39483 (char *) "self",(char *) "pt", NULL
39484 };
39485
39486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39488 if (!SWIG_IsOK(res1)) {
39489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39490 }
39491 arg1 = reinterpret_cast< wxWindow * >(argp1);
39492 {
39493 arg2 = &temp2;
39494 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39495 }
39496 {
39497 PyThreadState* __tstate = wxPyBeginAllowThreads();
39498 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39499 wxPyEndAllowThreads(__tstate);
39500 if (PyErr_Occurred()) SWIG_fail;
39501 }
39502 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39503 return resultobj;
39504 fail:
39505 return NULL;
39506 }
39507
39508
39509 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39510 PyObject *resultobj = 0;
39511 wxWindow *arg1 = (wxWindow *) 0 ;
39512 wxPoint *arg2 = 0 ;
39513 wxPoint result;
39514 void *argp1 = 0 ;
39515 int res1 = 0 ;
39516 wxPoint temp2 ;
39517 PyObject * obj0 = 0 ;
39518 PyObject * obj1 = 0 ;
39519 char * kwnames[] = {
39520 (char *) "self",(char *) "pt", NULL
39521 };
39522
39523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39525 if (!SWIG_IsOK(res1)) {
39526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39527 }
39528 arg1 = reinterpret_cast< wxWindow * >(argp1);
39529 {
39530 arg2 = &temp2;
39531 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39532 }
39533 {
39534 PyThreadState* __tstate = wxPyBeginAllowThreads();
39535 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39536 wxPyEndAllowThreads(__tstate);
39537 if (PyErr_Occurred()) SWIG_fail;
39538 }
39539 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39540 return resultobj;
39541 fail:
39542 return NULL;
39543 }
39544
39545
39546 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39547 PyObject *resultobj = 0;
39548 wxWindow *arg1 = (wxWindow *) 0 ;
39549 int arg2 ;
39550 int arg3 ;
39551 wxHitTest result;
39552 void *argp1 = 0 ;
39553 int res1 = 0 ;
39554 int val2 ;
39555 int ecode2 = 0 ;
39556 int val3 ;
39557 int ecode3 = 0 ;
39558 PyObject * obj0 = 0 ;
39559 PyObject * obj1 = 0 ;
39560 PyObject * obj2 = 0 ;
39561 char * kwnames[] = {
39562 (char *) "self",(char *) "x",(char *) "y", NULL
39563 };
39564
39565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39567 if (!SWIG_IsOK(res1)) {
39568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39569 }
39570 arg1 = reinterpret_cast< wxWindow * >(argp1);
39571 ecode2 = SWIG_AsVal_int(obj1, &val2);
39572 if (!SWIG_IsOK(ecode2)) {
39573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39574 }
39575 arg2 = static_cast< int >(val2);
39576 ecode3 = SWIG_AsVal_int(obj2, &val3);
39577 if (!SWIG_IsOK(ecode3)) {
39578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39579 }
39580 arg3 = static_cast< int >(val3);
39581 {
39582 PyThreadState* __tstate = wxPyBeginAllowThreads();
39583 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39584 wxPyEndAllowThreads(__tstate);
39585 if (PyErr_Occurred()) SWIG_fail;
39586 }
39587 resultobj = SWIG_From_int(static_cast< int >(result));
39588 return resultobj;
39589 fail:
39590 return NULL;
39591 }
39592
39593
39594 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39595 PyObject *resultobj = 0;
39596 wxWindow *arg1 = (wxWindow *) 0 ;
39597 wxPoint *arg2 = 0 ;
39598 wxHitTest result;
39599 void *argp1 = 0 ;
39600 int res1 = 0 ;
39601 wxPoint temp2 ;
39602 PyObject * obj0 = 0 ;
39603 PyObject * obj1 = 0 ;
39604 char * kwnames[] = {
39605 (char *) "self",(char *) "pt", NULL
39606 };
39607
39608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39610 if (!SWIG_IsOK(res1)) {
39611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39612 }
39613 arg1 = reinterpret_cast< wxWindow * >(argp1);
39614 {
39615 arg2 = &temp2;
39616 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39617 }
39618 {
39619 PyThreadState* __tstate = wxPyBeginAllowThreads();
39620 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39621 wxPyEndAllowThreads(__tstate);
39622 if (PyErr_Occurred()) SWIG_fail;
39623 }
39624 resultobj = SWIG_From_int(static_cast< int >(result));
39625 return resultobj;
39626 fail:
39627 return NULL;
39628 }
39629
39630
39631 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39632 PyObject *resultobj = 0;
39633 wxWindow *arg1 = (wxWindow *) 0 ;
39634 long arg2 ;
39635 wxBorder result;
39636 void *argp1 = 0 ;
39637 int res1 = 0 ;
39638 long val2 ;
39639 int ecode2 = 0 ;
39640
39641 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39643 if (!SWIG_IsOK(res1)) {
39644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39645 }
39646 arg1 = reinterpret_cast< wxWindow * >(argp1);
39647 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39648 if (!SWIG_IsOK(ecode2)) {
39649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39650 }
39651 arg2 = static_cast< long >(val2);
39652 {
39653 PyThreadState* __tstate = wxPyBeginAllowThreads();
39654 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39655 wxPyEndAllowThreads(__tstate);
39656 if (PyErr_Occurred()) SWIG_fail;
39657 }
39658 resultobj = SWIG_From_int(static_cast< int >(result));
39659 return resultobj;
39660 fail:
39661 return NULL;
39662 }
39663
39664
39665 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39666 PyObject *resultobj = 0;
39667 wxWindow *arg1 = (wxWindow *) 0 ;
39668 wxBorder result;
39669 void *argp1 = 0 ;
39670 int res1 = 0 ;
39671
39672 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39674 if (!SWIG_IsOK(res1)) {
39675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39676 }
39677 arg1 = reinterpret_cast< wxWindow * >(argp1);
39678 {
39679 PyThreadState* __tstate = wxPyBeginAllowThreads();
39680 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39681 wxPyEndAllowThreads(__tstate);
39682 if (PyErr_Occurred()) SWIG_fail;
39683 }
39684 resultobj = SWIG_From_int(static_cast< int >(result));
39685 return resultobj;
39686 fail:
39687 return NULL;
39688 }
39689
39690
39691 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39692 int argc;
39693 PyObject *argv[3];
39694
39695 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39696 --argc;
39697 if (argc == 1) {
39698 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39699 }
39700 if (argc == 2) {
39701 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39702 }
39703
39704 fail:
39705 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39706 return NULL;
39707 }
39708
39709
39710 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39711 PyObject *resultobj = 0;
39712 wxWindow *arg1 = (wxWindow *) 0 ;
39713 long arg2 = (long) wxUPDATE_UI_NONE ;
39714 void *argp1 = 0 ;
39715 int res1 = 0 ;
39716 long val2 ;
39717 int ecode2 = 0 ;
39718 PyObject * obj0 = 0 ;
39719 PyObject * obj1 = 0 ;
39720 char * kwnames[] = {
39721 (char *) "self",(char *) "flags", NULL
39722 };
39723
39724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39726 if (!SWIG_IsOK(res1)) {
39727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39728 }
39729 arg1 = reinterpret_cast< wxWindow * >(argp1);
39730 if (obj1) {
39731 ecode2 = SWIG_AsVal_long(obj1, &val2);
39732 if (!SWIG_IsOK(ecode2)) {
39733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39734 }
39735 arg2 = static_cast< long >(val2);
39736 }
39737 {
39738 PyThreadState* __tstate = wxPyBeginAllowThreads();
39739 (arg1)->UpdateWindowUI(arg2);
39740 wxPyEndAllowThreads(__tstate);
39741 if (PyErr_Occurred()) SWIG_fail;
39742 }
39743 resultobj = SWIG_Py_Void();
39744 return resultobj;
39745 fail:
39746 return NULL;
39747 }
39748
39749
39750 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39751 PyObject *resultobj = 0;
39752 wxWindow *arg1 = (wxWindow *) 0 ;
39753 wxMenu *arg2 = (wxMenu *) 0 ;
39754 int arg3 = (int) -1 ;
39755 int arg4 = (int) -1 ;
39756 bool result;
39757 void *argp1 = 0 ;
39758 int res1 = 0 ;
39759 void *argp2 = 0 ;
39760 int res2 = 0 ;
39761 int val3 ;
39762 int ecode3 = 0 ;
39763 int val4 ;
39764 int ecode4 = 0 ;
39765 PyObject * obj0 = 0 ;
39766 PyObject * obj1 = 0 ;
39767 PyObject * obj2 = 0 ;
39768 PyObject * obj3 = 0 ;
39769 char * kwnames[] = {
39770 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39771 };
39772
39773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39775 if (!SWIG_IsOK(res1)) {
39776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39777 }
39778 arg1 = reinterpret_cast< wxWindow * >(argp1);
39779 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39780 if (!SWIG_IsOK(res2)) {
39781 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39782 }
39783 arg2 = reinterpret_cast< wxMenu * >(argp2);
39784 if (obj2) {
39785 ecode3 = SWIG_AsVal_int(obj2, &val3);
39786 if (!SWIG_IsOK(ecode3)) {
39787 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39788 }
39789 arg3 = static_cast< int >(val3);
39790 }
39791 if (obj3) {
39792 ecode4 = SWIG_AsVal_int(obj3, &val4);
39793 if (!SWIG_IsOK(ecode4)) {
39794 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39795 }
39796 arg4 = static_cast< int >(val4);
39797 }
39798 {
39799 PyThreadState* __tstate = wxPyBeginAllowThreads();
39800 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39801 wxPyEndAllowThreads(__tstate);
39802 if (PyErr_Occurred()) SWIG_fail;
39803 }
39804 {
39805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39806 }
39807 return resultobj;
39808 fail:
39809 return NULL;
39810 }
39811
39812
39813 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39814 PyObject *resultobj = 0;
39815 wxWindow *arg1 = (wxWindow *) 0 ;
39816 wxMenu *arg2 = (wxMenu *) 0 ;
39817 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39818 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39819 bool result;
39820 void *argp1 = 0 ;
39821 int res1 = 0 ;
39822 void *argp2 = 0 ;
39823 int res2 = 0 ;
39824 wxPoint temp3 ;
39825 PyObject * obj0 = 0 ;
39826 PyObject * obj1 = 0 ;
39827 PyObject * obj2 = 0 ;
39828 char * kwnames[] = {
39829 (char *) "self",(char *) "menu",(char *) "pos", NULL
39830 };
39831
39832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39834 if (!SWIG_IsOK(res1)) {
39835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39836 }
39837 arg1 = reinterpret_cast< wxWindow * >(argp1);
39838 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39839 if (!SWIG_IsOK(res2)) {
39840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39841 }
39842 arg2 = reinterpret_cast< wxMenu * >(argp2);
39843 if (obj2) {
39844 {
39845 arg3 = &temp3;
39846 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39847 }
39848 }
39849 {
39850 PyThreadState* __tstate = wxPyBeginAllowThreads();
39851 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39852 wxPyEndAllowThreads(__tstate);
39853 if (PyErr_Occurred()) SWIG_fail;
39854 }
39855 {
39856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39857 }
39858 return resultobj;
39859 fail:
39860 return NULL;
39861 }
39862
39863
39864 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39865 PyObject *resultobj = 0;
39866 wxWindow *arg1 = (wxWindow *) 0 ;
39867 bool result;
39868 void *argp1 = 0 ;
39869 int res1 = 0 ;
39870 PyObject *swig_obj[1] ;
39871
39872 if (!args) SWIG_fail;
39873 swig_obj[0] = args;
39874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39875 if (!SWIG_IsOK(res1)) {
39876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39877 }
39878 arg1 = reinterpret_cast< wxWindow * >(argp1);
39879 {
39880 PyThreadState* __tstate = wxPyBeginAllowThreads();
39881 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39882 wxPyEndAllowThreads(__tstate);
39883 if (PyErr_Occurred()) SWIG_fail;
39884 }
39885 {
39886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39887 }
39888 return resultobj;
39889 fail:
39890 return NULL;
39891 }
39892
39893
39894 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39895 PyObject *resultobj = 0;
39896 wxWindow *arg1 = (wxWindow *) 0 ;
39897 long result;
39898 void *argp1 = 0 ;
39899 int res1 = 0 ;
39900 PyObject *swig_obj[1] ;
39901
39902 if (!args) SWIG_fail;
39903 swig_obj[0] = args;
39904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39905 if (!SWIG_IsOK(res1)) {
39906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39907 }
39908 arg1 = reinterpret_cast< wxWindow * >(argp1);
39909 {
39910 PyThreadState* __tstate = wxPyBeginAllowThreads();
39911 result = (long)wxWindow_GetHandle(arg1);
39912 wxPyEndAllowThreads(__tstate);
39913 if (PyErr_Occurred()) SWIG_fail;
39914 }
39915 resultobj = SWIG_From_long(static_cast< long >(result));
39916 return resultobj;
39917 fail:
39918 return NULL;
39919 }
39920
39921
39922 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39923 PyObject *resultobj = 0;
39924 wxWindow *arg1 = (wxWindow *) 0 ;
39925 long arg2 ;
39926 void *argp1 = 0 ;
39927 int res1 = 0 ;
39928 long val2 ;
39929 int ecode2 = 0 ;
39930 PyObject * obj0 = 0 ;
39931 PyObject * obj1 = 0 ;
39932 char * kwnames[] = {
39933 (char *) "self",(char *) "handle", NULL
39934 };
39935
39936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39938 if (!SWIG_IsOK(res1)) {
39939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39940 }
39941 arg1 = reinterpret_cast< wxWindow * >(argp1);
39942 ecode2 = SWIG_AsVal_long(obj1, &val2);
39943 if (!SWIG_IsOK(ecode2)) {
39944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39945 }
39946 arg2 = static_cast< long >(val2);
39947 {
39948 PyThreadState* __tstate = wxPyBeginAllowThreads();
39949 wxWindow_AssociateHandle(arg1,arg2);
39950 wxPyEndAllowThreads(__tstate);
39951 if (PyErr_Occurred()) SWIG_fail;
39952 }
39953 resultobj = SWIG_Py_Void();
39954 return resultobj;
39955 fail:
39956 return NULL;
39957 }
39958
39959
39960 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39961 PyObject *resultobj = 0;
39962 wxWindow *arg1 = (wxWindow *) 0 ;
39963 void *argp1 = 0 ;
39964 int res1 = 0 ;
39965 PyObject *swig_obj[1] ;
39966
39967 if (!args) SWIG_fail;
39968 swig_obj[0] = args;
39969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39970 if (!SWIG_IsOK(res1)) {
39971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39972 }
39973 arg1 = reinterpret_cast< wxWindow * >(argp1);
39974 {
39975 PyThreadState* __tstate = wxPyBeginAllowThreads();
39976 (arg1)->DissociateHandle();
39977 wxPyEndAllowThreads(__tstate);
39978 if (PyErr_Occurred()) SWIG_fail;
39979 }
39980 resultobj = SWIG_Py_Void();
39981 return resultobj;
39982 fail:
39983 return NULL;
39984 }
39985
39986
39987 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39988 PyObject *resultobj = 0;
39989 wxWindow *arg1 = (wxWindow *) 0 ;
39990 wxPaintEvent *arg2 = 0 ;
39991 void *argp1 = 0 ;
39992 int res1 = 0 ;
39993 void *argp2 = 0 ;
39994 int res2 = 0 ;
39995 PyObject * obj0 = 0 ;
39996 PyObject * obj1 = 0 ;
39997 char * kwnames[] = {
39998 (char *) "self",(char *) "event", NULL
39999 };
40000
40001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
40002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40003 if (!SWIG_IsOK(res1)) {
40004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
40005 }
40006 arg1 = reinterpret_cast< wxWindow * >(argp1);
40007 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
40008 if (!SWIG_IsOK(res2)) {
40009 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
40010 }
40011 if (!argp2) {
40012 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
40013 }
40014 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
40015 {
40016 PyThreadState* __tstate = wxPyBeginAllowThreads();
40017 (arg1)->OnPaint(*arg2);
40018 wxPyEndAllowThreads(__tstate);
40019 if (PyErr_Occurred()) SWIG_fail;
40020 }
40021 resultobj = SWIG_Py_Void();
40022 return resultobj;
40023 fail:
40024 return NULL;
40025 }
40026
40027
40028 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40029 PyObject *resultobj = 0;
40030 wxWindow *arg1 = (wxWindow *) 0 ;
40031 int arg2 ;
40032 bool result;
40033 void *argp1 = 0 ;
40034 int res1 = 0 ;
40035 int val2 ;
40036 int ecode2 = 0 ;
40037 PyObject * obj0 = 0 ;
40038 PyObject * obj1 = 0 ;
40039 char * kwnames[] = {
40040 (char *) "self",(char *) "orient", NULL
40041 };
40042
40043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
40044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40045 if (!SWIG_IsOK(res1)) {
40046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
40047 }
40048 arg1 = reinterpret_cast< wxWindow * >(argp1);
40049 ecode2 = SWIG_AsVal_int(obj1, &val2);
40050 if (!SWIG_IsOK(ecode2)) {
40051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
40052 }
40053 arg2 = static_cast< int >(val2);
40054 {
40055 PyThreadState* __tstate = wxPyBeginAllowThreads();
40056 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
40057 wxPyEndAllowThreads(__tstate);
40058 if (PyErr_Occurred()) SWIG_fail;
40059 }
40060 {
40061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40062 }
40063 return resultobj;
40064 fail:
40065 return NULL;
40066 }
40067
40068
40069 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40070 PyObject *resultobj = 0;
40071 wxWindow *arg1 = (wxWindow *) 0 ;
40072 int arg2 ;
40073 int arg3 ;
40074 int arg4 ;
40075 int arg5 ;
40076 bool arg6 = (bool) true ;
40077 void *argp1 = 0 ;
40078 int res1 = 0 ;
40079 int val2 ;
40080 int ecode2 = 0 ;
40081 int val3 ;
40082 int ecode3 = 0 ;
40083 int val4 ;
40084 int ecode4 = 0 ;
40085 int val5 ;
40086 int ecode5 = 0 ;
40087 bool val6 ;
40088 int ecode6 = 0 ;
40089 PyObject * obj0 = 0 ;
40090 PyObject * obj1 = 0 ;
40091 PyObject * obj2 = 0 ;
40092 PyObject * obj3 = 0 ;
40093 PyObject * obj4 = 0 ;
40094 PyObject * obj5 = 0 ;
40095 char * kwnames[] = {
40096 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
40097 };
40098
40099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40101 if (!SWIG_IsOK(res1)) {
40102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
40103 }
40104 arg1 = reinterpret_cast< wxWindow * >(argp1);
40105 ecode2 = SWIG_AsVal_int(obj1, &val2);
40106 if (!SWIG_IsOK(ecode2)) {
40107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
40108 }
40109 arg2 = static_cast< int >(val2);
40110 ecode3 = SWIG_AsVal_int(obj2, &val3);
40111 if (!SWIG_IsOK(ecode3)) {
40112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
40113 }
40114 arg3 = static_cast< int >(val3);
40115 ecode4 = SWIG_AsVal_int(obj3, &val4);
40116 if (!SWIG_IsOK(ecode4)) {
40117 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
40118 }
40119 arg4 = static_cast< int >(val4);
40120 ecode5 = SWIG_AsVal_int(obj4, &val5);
40121 if (!SWIG_IsOK(ecode5)) {
40122 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
40123 }
40124 arg5 = static_cast< int >(val5);
40125 if (obj5) {
40126 ecode6 = SWIG_AsVal_bool(obj5, &val6);
40127 if (!SWIG_IsOK(ecode6)) {
40128 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
40129 }
40130 arg6 = static_cast< bool >(val6);
40131 }
40132 {
40133 PyThreadState* __tstate = wxPyBeginAllowThreads();
40134 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
40135 wxPyEndAllowThreads(__tstate);
40136 if (PyErr_Occurred()) SWIG_fail;
40137 }
40138 resultobj = SWIG_Py_Void();
40139 return resultobj;
40140 fail:
40141 return NULL;
40142 }
40143
40144
40145 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40146 PyObject *resultobj = 0;
40147 wxWindow *arg1 = (wxWindow *) 0 ;
40148 int arg2 ;
40149 int arg3 ;
40150 bool arg4 = (bool) true ;
40151 void *argp1 = 0 ;
40152 int res1 = 0 ;
40153 int val2 ;
40154 int ecode2 = 0 ;
40155 int val3 ;
40156 int ecode3 = 0 ;
40157 bool val4 ;
40158 int ecode4 = 0 ;
40159 PyObject * obj0 = 0 ;
40160 PyObject * obj1 = 0 ;
40161 PyObject * obj2 = 0 ;
40162 PyObject * obj3 = 0 ;
40163 char * kwnames[] = {
40164 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
40165 };
40166
40167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40169 if (!SWIG_IsOK(res1)) {
40170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
40171 }
40172 arg1 = reinterpret_cast< wxWindow * >(argp1);
40173 ecode2 = SWIG_AsVal_int(obj1, &val2);
40174 if (!SWIG_IsOK(ecode2)) {
40175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
40176 }
40177 arg2 = static_cast< int >(val2);
40178 ecode3 = SWIG_AsVal_int(obj2, &val3);
40179 if (!SWIG_IsOK(ecode3)) {
40180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
40181 }
40182 arg3 = static_cast< int >(val3);
40183 if (obj3) {
40184 ecode4 = SWIG_AsVal_bool(obj3, &val4);
40185 if (!SWIG_IsOK(ecode4)) {
40186 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
40187 }
40188 arg4 = static_cast< bool >(val4);
40189 }
40190 {
40191 PyThreadState* __tstate = wxPyBeginAllowThreads();
40192 (arg1)->SetScrollPos(arg2,arg3,arg4);
40193 wxPyEndAllowThreads(__tstate);
40194 if (PyErr_Occurred()) SWIG_fail;
40195 }
40196 resultobj = SWIG_Py_Void();
40197 return resultobj;
40198 fail:
40199 return NULL;
40200 }
40201
40202
40203 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40204 PyObject *resultobj = 0;
40205 wxWindow *arg1 = (wxWindow *) 0 ;
40206 int arg2 ;
40207 int result;
40208 void *argp1 = 0 ;
40209 int res1 = 0 ;
40210 int val2 ;
40211 int ecode2 = 0 ;
40212 PyObject * obj0 = 0 ;
40213 PyObject * obj1 = 0 ;
40214 char * kwnames[] = {
40215 (char *) "self",(char *) "orientation", NULL
40216 };
40217
40218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
40219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40220 if (!SWIG_IsOK(res1)) {
40221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
40222 }
40223 arg1 = reinterpret_cast< wxWindow * >(argp1);
40224 ecode2 = SWIG_AsVal_int(obj1, &val2);
40225 if (!SWIG_IsOK(ecode2)) {
40226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
40227 }
40228 arg2 = static_cast< int >(val2);
40229 {
40230 PyThreadState* __tstate = wxPyBeginAllowThreads();
40231 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
40232 wxPyEndAllowThreads(__tstate);
40233 if (PyErr_Occurred()) SWIG_fail;
40234 }
40235 resultobj = SWIG_From_int(static_cast< int >(result));
40236 return resultobj;
40237 fail:
40238 return NULL;
40239 }
40240
40241
40242 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40243 PyObject *resultobj = 0;
40244 wxWindow *arg1 = (wxWindow *) 0 ;
40245 int arg2 ;
40246 int result;
40247 void *argp1 = 0 ;
40248 int res1 = 0 ;
40249 int val2 ;
40250 int ecode2 = 0 ;
40251 PyObject * obj0 = 0 ;
40252 PyObject * obj1 = 0 ;
40253 char * kwnames[] = {
40254 (char *) "self",(char *) "orientation", NULL
40255 };
40256
40257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
40258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40259 if (!SWIG_IsOK(res1)) {
40260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
40261 }
40262 arg1 = reinterpret_cast< wxWindow * >(argp1);
40263 ecode2 = SWIG_AsVal_int(obj1, &val2);
40264 if (!SWIG_IsOK(ecode2)) {
40265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
40266 }
40267 arg2 = static_cast< int >(val2);
40268 {
40269 PyThreadState* __tstate = wxPyBeginAllowThreads();
40270 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
40271 wxPyEndAllowThreads(__tstate);
40272 if (PyErr_Occurred()) SWIG_fail;
40273 }
40274 resultobj = SWIG_From_int(static_cast< int >(result));
40275 return resultobj;
40276 fail:
40277 return NULL;
40278 }
40279
40280
40281 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40282 PyObject *resultobj = 0;
40283 wxWindow *arg1 = (wxWindow *) 0 ;
40284 int arg2 ;
40285 int result;
40286 void *argp1 = 0 ;
40287 int res1 = 0 ;
40288 int val2 ;
40289 int ecode2 = 0 ;
40290 PyObject * obj0 = 0 ;
40291 PyObject * obj1 = 0 ;
40292 char * kwnames[] = {
40293 (char *) "self",(char *) "orientation", NULL
40294 };
40295
40296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
40297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40298 if (!SWIG_IsOK(res1)) {
40299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
40300 }
40301 arg1 = reinterpret_cast< wxWindow * >(argp1);
40302 ecode2 = SWIG_AsVal_int(obj1, &val2);
40303 if (!SWIG_IsOK(ecode2)) {
40304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
40305 }
40306 arg2 = static_cast< int >(val2);
40307 {
40308 PyThreadState* __tstate = wxPyBeginAllowThreads();
40309 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
40310 wxPyEndAllowThreads(__tstate);
40311 if (PyErr_Occurred()) SWIG_fail;
40312 }
40313 resultobj = SWIG_From_int(static_cast< int >(result));
40314 return resultobj;
40315 fail:
40316 return NULL;
40317 }
40318
40319
40320 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40321 PyObject *resultobj = 0;
40322 wxWindow *arg1 = (wxWindow *) 0 ;
40323 int arg2 ;
40324 int arg3 ;
40325 wxRect *arg4 = (wxRect *) NULL ;
40326 void *argp1 = 0 ;
40327 int res1 = 0 ;
40328 int val2 ;
40329 int ecode2 = 0 ;
40330 int val3 ;
40331 int ecode3 = 0 ;
40332 void *argp4 = 0 ;
40333 int res4 = 0 ;
40334 PyObject * obj0 = 0 ;
40335 PyObject * obj1 = 0 ;
40336 PyObject * obj2 = 0 ;
40337 PyObject * obj3 = 0 ;
40338 char * kwnames[] = {
40339 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
40340 };
40341
40342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40344 if (!SWIG_IsOK(res1)) {
40345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
40346 }
40347 arg1 = reinterpret_cast< wxWindow * >(argp1);
40348 ecode2 = SWIG_AsVal_int(obj1, &val2);
40349 if (!SWIG_IsOK(ecode2)) {
40350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
40351 }
40352 arg2 = static_cast< int >(val2);
40353 ecode3 = SWIG_AsVal_int(obj2, &val3);
40354 if (!SWIG_IsOK(ecode3)) {
40355 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
40356 }
40357 arg3 = static_cast< int >(val3);
40358 if (obj3) {
40359 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
40360 if (!SWIG_IsOK(res4)) {
40361 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
40362 }
40363 arg4 = reinterpret_cast< wxRect * >(argp4);
40364 }
40365 {
40366 PyThreadState* __tstate = wxPyBeginAllowThreads();
40367 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
40368 wxPyEndAllowThreads(__tstate);
40369 if (PyErr_Occurred()) SWIG_fail;
40370 }
40371 resultobj = SWIG_Py_Void();
40372 return resultobj;
40373 fail:
40374 return NULL;
40375 }
40376
40377
40378 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40379 PyObject *resultobj = 0;
40380 wxWindow *arg1 = (wxWindow *) 0 ;
40381 int arg2 ;
40382 bool result;
40383 void *argp1 = 0 ;
40384 int res1 = 0 ;
40385 int val2 ;
40386 int ecode2 = 0 ;
40387 PyObject * obj0 = 0 ;
40388 PyObject * obj1 = 0 ;
40389 char * kwnames[] = {
40390 (char *) "self",(char *) "lines", NULL
40391 };
40392
40393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40395 if (!SWIG_IsOK(res1)) {
40396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40397 }
40398 arg1 = reinterpret_cast< wxWindow * >(argp1);
40399 ecode2 = SWIG_AsVal_int(obj1, &val2);
40400 if (!SWIG_IsOK(ecode2)) {
40401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40402 }
40403 arg2 = static_cast< int >(val2);
40404 {
40405 PyThreadState* __tstate = wxPyBeginAllowThreads();
40406 result = (bool)(arg1)->ScrollLines(arg2);
40407 wxPyEndAllowThreads(__tstate);
40408 if (PyErr_Occurred()) SWIG_fail;
40409 }
40410 {
40411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40412 }
40413 return resultobj;
40414 fail:
40415 return NULL;
40416 }
40417
40418
40419 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40420 PyObject *resultobj = 0;
40421 wxWindow *arg1 = (wxWindow *) 0 ;
40422 int arg2 ;
40423 bool result;
40424 void *argp1 = 0 ;
40425 int res1 = 0 ;
40426 int val2 ;
40427 int ecode2 = 0 ;
40428 PyObject * obj0 = 0 ;
40429 PyObject * obj1 = 0 ;
40430 char * kwnames[] = {
40431 (char *) "self",(char *) "pages", NULL
40432 };
40433
40434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40436 if (!SWIG_IsOK(res1)) {
40437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40438 }
40439 arg1 = reinterpret_cast< wxWindow * >(argp1);
40440 ecode2 = SWIG_AsVal_int(obj1, &val2);
40441 if (!SWIG_IsOK(ecode2)) {
40442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40443 }
40444 arg2 = static_cast< int >(val2);
40445 {
40446 PyThreadState* __tstate = wxPyBeginAllowThreads();
40447 result = (bool)(arg1)->ScrollPages(arg2);
40448 wxPyEndAllowThreads(__tstate);
40449 if (PyErr_Occurred()) SWIG_fail;
40450 }
40451 {
40452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40453 }
40454 return resultobj;
40455 fail:
40456 return NULL;
40457 }
40458
40459
40460 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40461 PyObject *resultobj = 0;
40462 wxWindow *arg1 = (wxWindow *) 0 ;
40463 bool result;
40464 void *argp1 = 0 ;
40465 int res1 = 0 ;
40466 PyObject *swig_obj[1] ;
40467
40468 if (!args) SWIG_fail;
40469 swig_obj[0] = args;
40470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40471 if (!SWIG_IsOK(res1)) {
40472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40473 }
40474 arg1 = reinterpret_cast< wxWindow * >(argp1);
40475 {
40476 PyThreadState* __tstate = wxPyBeginAllowThreads();
40477 result = (bool)(arg1)->LineUp();
40478 wxPyEndAllowThreads(__tstate);
40479 if (PyErr_Occurred()) SWIG_fail;
40480 }
40481 {
40482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40483 }
40484 return resultobj;
40485 fail:
40486 return NULL;
40487 }
40488
40489
40490 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40491 PyObject *resultobj = 0;
40492 wxWindow *arg1 = (wxWindow *) 0 ;
40493 bool result;
40494 void *argp1 = 0 ;
40495 int res1 = 0 ;
40496 PyObject *swig_obj[1] ;
40497
40498 if (!args) SWIG_fail;
40499 swig_obj[0] = args;
40500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40501 if (!SWIG_IsOK(res1)) {
40502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40503 }
40504 arg1 = reinterpret_cast< wxWindow * >(argp1);
40505 {
40506 PyThreadState* __tstate = wxPyBeginAllowThreads();
40507 result = (bool)(arg1)->LineDown();
40508 wxPyEndAllowThreads(__tstate);
40509 if (PyErr_Occurred()) SWIG_fail;
40510 }
40511 {
40512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40513 }
40514 return resultobj;
40515 fail:
40516 return NULL;
40517 }
40518
40519
40520 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40521 PyObject *resultobj = 0;
40522 wxWindow *arg1 = (wxWindow *) 0 ;
40523 bool result;
40524 void *argp1 = 0 ;
40525 int res1 = 0 ;
40526 PyObject *swig_obj[1] ;
40527
40528 if (!args) SWIG_fail;
40529 swig_obj[0] = args;
40530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40531 if (!SWIG_IsOK(res1)) {
40532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40533 }
40534 arg1 = reinterpret_cast< wxWindow * >(argp1);
40535 {
40536 PyThreadState* __tstate = wxPyBeginAllowThreads();
40537 result = (bool)(arg1)->PageUp();
40538 wxPyEndAllowThreads(__tstate);
40539 if (PyErr_Occurred()) SWIG_fail;
40540 }
40541 {
40542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40543 }
40544 return resultobj;
40545 fail:
40546 return NULL;
40547 }
40548
40549
40550 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40551 PyObject *resultobj = 0;
40552 wxWindow *arg1 = (wxWindow *) 0 ;
40553 bool result;
40554 void *argp1 = 0 ;
40555 int res1 = 0 ;
40556 PyObject *swig_obj[1] ;
40557
40558 if (!args) SWIG_fail;
40559 swig_obj[0] = args;
40560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40561 if (!SWIG_IsOK(res1)) {
40562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40563 }
40564 arg1 = reinterpret_cast< wxWindow * >(argp1);
40565 {
40566 PyThreadState* __tstate = wxPyBeginAllowThreads();
40567 result = (bool)(arg1)->PageDown();
40568 wxPyEndAllowThreads(__tstate);
40569 if (PyErr_Occurred()) SWIG_fail;
40570 }
40571 {
40572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40573 }
40574 return resultobj;
40575 fail:
40576 return NULL;
40577 }
40578
40579
40580 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40581 PyObject *resultobj = 0;
40582 wxWindow *arg1 = (wxWindow *) 0 ;
40583 wxString *arg2 = 0 ;
40584 void *argp1 = 0 ;
40585 int res1 = 0 ;
40586 bool temp2 = false ;
40587 PyObject * obj0 = 0 ;
40588 PyObject * obj1 = 0 ;
40589 char * kwnames[] = {
40590 (char *) "self",(char *) "text", NULL
40591 };
40592
40593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40595 if (!SWIG_IsOK(res1)) {
40596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40597 }
40598 arg1 = reinterpret_cast< wxWindow * >(argp1);
40599 {
40600 arg2 = wxString_in_helper(obj1);
40601 if (arg2 == NULL) SWIG_fail;
40602 temp2 = true;
40603 }
40604 {
40605 PyThreadState* __tstate = wxPyBeginAllowThreads();
40606 (arg1)->SetHelpText((wxString const &)*arg2);
40607 wxPyEndAllowThreads(__tstate);
40608 if (PyErr_Occurred()) SWIG_fail;
40609 }
40610 resultobj = SWIG_Py_Void();
40611 {
40612 if (temp2)
40613 delete arg2;
40614 }
40615 return resultobj;
40616 fail:
40617 {
40618 if (temp2)
40619 delete arg2;
40620 }
40621 return NULL;
40622 }
40623
40624
40625 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40626 PyObject *resultobj = 0;
40627 wxWindow *arg1 = (wxWindow *) 0 ;
40628 wxString *arg2 = 0 ;
40629 void *argp1 = 0 ;
40630 int res1 = 0 ;
40631 bool temp2 = false ;
40632 PyObject * obj0 = 0 ;
40633 PyObject * obj1 = 0 ;
40634 char * kwnames[] = {
40635 (char *) "self",(char *) "text", NULL
40636 };
40637
40638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40640 if (!SWIG_IsOK(res1)) {
40641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40642 }
40643 arg1 = reinterpret_cast< wxWindow * >(argp1);
40644 {
40645 arg2 = wxString_in_helper(obj1);
40646 if (arg2 == NULL) SWIG_fail;
40647 temp2 = true;
40648 }
40649 {
40650 PyThreadState* __tstate = wxPyBeginAllowThreads();
40651 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40652 wxPyEndAllowThreads(__tstate);
40653 if (PyErr_Occurred()) SWIG_fail;
40654 }
40655 resultobj = SWIG_Py_Void();
40656 {
40657 if (temp2)
40658 delete arg2;
40659 }
40660 return resultobj;
40661 fail:
40662 {
40663 if (temp2)
40664 delete arg2;
40665 }
40666 return NULL;
40667 }
40668
40669
40670 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40671 PyObject *resultobj = 0;
40672 wxWindow *arg1 = (wxWindow *) 0 ;
40673 wxPoint *arg2 = 0 ;
40674 wxHelpEvent::Origin arg3 ;
40675 wxString result;
40676 void *argp1 = 0 ;
40677 int res1 = 0 ;
40678 wxPoint temp2 ;
40679 void *argp3 ;
40680 int res3 = 0 ;
40681 PyObject * obj0 = 0 ;
40682 PyObject * obj1 = 0 ;
40683 PyObject * obj2 = 0 ;
40684 char * kwnames[] = {
40685 (char *) "self",(char *) "pt",(char *) "origin", NULL
40686 };
40687
40688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40690 if (!SWIG_IsOK(res1)) {
40691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40692 }
40693 arg1 = reinterpret_cast< wxWindow * >(argp1);
40694 {
40695 arg2 = &temp2;
40696 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40697 }
40698 {
40699 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40700 if (!SWIG_IsOK(res3)) {
40701 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40702 }
40703 if (!argp3) {
40704 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40705 } else {
40706 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40707 arg3 = *temp;
40708 if (SWIG_IsNewObj(res3)) delete temp;
40709 }
40710 }
40711 {
40712 PyThreadState* __tstate = wxPyBeginAllowThreads();
40713 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40714 wxPyEndAllowThreads(__tstate);
40715 if (PyErr_Occurred()) SWIG_fail;
40716 }
40717 {
40718 #if wxUSE_UNICODE
40719 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40720 #else
40721 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40722 #endif
40723 }
40724 return resultobj;
40725 fail:
40726 return NULL;
40727 }
40728
40729
40730 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40731 PyObject *resultobj = 0;
40732 wxWindow *arg1 = (wxWindow *) 0 ;
40733 wxString result;
40734 void *argp1 = 0 ;
40735 int res1 = 0 ;
40736 PyObject *swig_obj[1] ;
40737
40738 if (!args) SWIG_fail;
40739 swig_obj[0] = args;
40740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40741 if (!SWIG_IsOK(res1)) {
40742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40743 }
40744 arg1 = reinterpret_cast< wxWindow * >(argp1);
40745 {
40746 PyThreadState* __tstate = wxPyBeginAllowThreads();
40747 result = ((wxWindow const *)arg1)->GetHelpText();
40748 wxPyEndAllowThreads(__tstate);
40749 if (PyErr_Occurred()) SWIG_fail;
40750 }
40751 {
40752 #if wxUSE_UNICODE
40753 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40754 #else
40755 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40756 #endif
40757 }
40758 return resultobj;
40759 fail:
40760 return NULL;
40761 }
40762
40763
40764 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40765 PyObject *resultobj = 0;
40766 wxWindow *arg1 = (wxWindow *) 0 ;
40767 wxString *arg2 = 0 ;
40768 void *argp1 = 0 ;
40769 int res1 = 0 ;
40770 bool temp2 = false ;
40771 PyObject * obj0 = 0 ;
40772 PyObject * obj1 = 0 ;
40773 char * kwnames[] = {
40774 (char *) "self",(char *) "tip", NULL
40775 };
40776
40777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40779 if (!SWIG_IsOK(res1)) {
40780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40781 }
40782 arg1 = reinterpret_cast< wxWindow * >(argp1);
40783 {
40784 arg2 = wxString_in_helper(obj1);
40785 if (arg2 == NULL) SWIG_fail;
40786 temp2 = true;
40787 }
40788 {
40789 PyThreadState* __tstate = wxPyBeginAllowThreads();
40790 (arg1)->SetToolTip((wxString const &)*arg2);
40791 wxPyEndAllowThreads(__tstate);
40792 if (PyErr_Occurred()) SWIG_fail;
40793 }
40794 resultobj = SWIG_Py_Void();
40795 {
40796 if (temp2)
40797 delete arg2;
40798 }
40799 return resultobj;
40800 fail:
40801 {
40802 if (temp2)
40803 delete arg2;
40804 }
40805 return NULL;
40806 }
40807
40808
40809 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40810 PyObject *resultobj = 0;
40811 wxWindow *arg1 = (wxWindow *) 0 ;
40812 wxToolTip *arg2 = (wxToolTip *) 0 ;
40813 void *argp1 = 0 ;
40814 int res1 = 0 ;
40815 int res2 = 0 ;
40816 PyObject * obj0 = 0 ;
40817 PyObject * obj1 = 0 ;
40818 char * kwnames[] = {
40819 (char *) "self",(char *) "tip", NULL
40820 };
40821
40822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40824 if (!SWIG_IsOK(res1)) {
40825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40826 }
40827 arg1 = reinterpret_cast< wxWindow * >(argp1);
40828 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40829 if (!SWIG_IsOK(res2)) {
40830 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40831 }
40832 {
40833 PyThreadState* __tstate = wxPyBeginAllowThreads();
40834 (arg1)->SetToolTip(arg2);
40835 wxPyEndAllowThreads(__tstate);
40836 if (PyErr_Occurred()) SWIG_fail;
40837 }
40838 resultobj = SWIG_Py_Void();
40839 return resultobj;
40840 fail:
40841 return NULL;
40842 }
40843
40844
40845 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40846 PyObject *resultobj = 0;
40847 wxWindow *arg1 = (wxWindow *) 0 ;
40848 wxToolTip *result = 0 ;
40849 void *argp1 = 0 ;
40850 int res1 = 0 ;
40851 PyObject *swig_obj[1] ;
40852
40853 if (!args) SWIG_fail;
40854 swig_obj[0] = args;
40855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40856 if (!SWIG_IsOK(res1)) {
40857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40858 }
40859 arg1 = reinterpret_cast< wxWindow * >(argp1);
40860 {
40861 PyThreadState* __tstate = wxPyBeginAllowThreads();
40862 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40863 wxPyEndAllowThreads(__tstate);
40864 if (PyErr_Occurred()) SWIG_fail;
40865 }
40866 {
40867 resultobj = wxPyMake_wxObject(result, (bool)0);
40868 }
40869 return resultobj;
40870 fail:
40871 return NULL;
40872 }
40873
40874
40875 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40876 PyObject *resultobj = 0;
40877 wxWindow *arg1 = (wxWindow *) 0 ;
40878 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40879 void *argp1 = 0 ;
40880 int res1 = 0 ;
40881 int res2 = 0 ;
40882 PyObject * obj0 = 0 ;
40883 PyObject * obj1 = 0 ;
40884 char * kwnames[] = {
40885 (char *) "self",(char *) "dropTarget", NULL
40886 };
40887
40888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40890 if (!SWIG_IsOK(res1)) {
40891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40892 }
40893 arg1 = reinterpret_cast< wxWindow * >(argp1);
40894 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40895 if (!SWIG_IsOK(res2)) {
40896 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40897 }
40898 {
40899 PyThreadState* __tstate = wxPyBeginAllowThreads();
40900 (arg1)->SetDropTarget(arg2);
40901 wxPyEndAllowThreads(__tstate);
40902 if (PyErr_Occurred()) SWIG_fail;
40903 }
40904 resultobj = SWIG_Py_Void();
40905 return resultobj;
40906 fail:
40907 return NULL;
40908 }
40909
40910
40911 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40912 PyObject *resultobj = 0;
40913 wxWindow *arg1 = (wxWindow *) 0 ;
40914 wxPyDropTarget *result = 0 ;
40915 void *argp1 = 0 ;
40916 int res1 = 0 ;
40917 PyObject *swig_obj[1] ;
40918
40919 if (!args) SWIG_fail;
40920 swig_obj[0] = args;
40921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40922 if (!SWIG_IsOK(res1)) {
40923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40924 }
40925 arg1 = reinterpret_cast< wxWindow * >(argp1);
40926 {
40927 PyThreadState* __tstate = wxPyBeginAllowThreads();
40928 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40929 wxPyEndAllowThreads(__tstate);
40930 if (PyErr_Occurred()) SWIG_fail;
40931 }
40932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40933 return resultobj;
40934 fail:
40935 return NULL;
40936 }
40937
40938
40939 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40940 PyObject *resultobj = 0;
40941 wxWindow *arg1 = (wxWindow *) 0 ;
40942 bool arg2 ;
40943 void *argp1 = 0 ;
40944 int res1 = 0 ;
40945 bool val2 ;
40946 int ecode2 = 0 ;
40947 PyObject * obj0 = 0 ;
40948 PyObject * obj1 = 0 ;
40949 char * kwnames[] = {
40950 (char *) "self",(char *) "accept", NULL
40951 };
40952
40953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40955 if (!SWIG_IsOK(res1)) {
40956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40957 }
40958 arg1 = reinterpret_cast< wxWindow * >(argp1);
40959 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40960 if (!SWIG_IsOK(ecode2)) {
40961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40962 }
40963 arg2 = static_cast< bool >(val2);
40964 {
40965 PyThreadState* __tstate = wxPyBeginAllowThreads();
40966 (arg1)->DragAcceptFiles(arg2);
40967 wxPyEndAllowThreads(__tstate);
40968 if (PyErr_Occurred()) SWIG_fail;
40969 }
40970 resultobj = SWIG_Py_Void();
40971 return resultobj;
40972 fail:
40973 return NULL;
40974 }
40975
40976
40977 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40978 PyObject *resultobj = 0;
40979 wxWindow *arg1 = (wxWindow *) 0 ;
40980 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40981 void *argp1 = 0 ;
40982 int res1 = 0 ;
40983 int res2 = 0 ;
40984 PyObject * obj0 = 0 ;
40985 PyObject * obj1 = 0 ;
40986 char * kwnames[] = {
40987 (char *) "self",(char *) "constraints", NULL
40988 };
40989
40990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40992 if (!SWIG_IsOK(res1)) {
40993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40994 }
40995 arg1 = reinterpret_cast< wxWindow * >(argp1);
40996 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40997 if (!SWIG_IsOK(res2)) {
40998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40999 }
41000 {
41001 PyThreadState* __tstate = wxPyBeginAllowThreads();
41002 (arg1)->SetConstraints(arg2);
41003 wxPyEndAllowThreads(__tstate);
41004 if (PyErr_Occurred()) SWIG_fail;
41005 }
41006 resultobj = SWIG_Py_Void();
41007 return resultobj;
41008 fail:
41009 return NULL;
41010 }
41011
41012
41013 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41014 PyObject *resultobj = 0;
41015 wxWindow *arg1 = (wxWindow *) 0 ;
41016 wxLayoutConstraints *result = 0 ;
41017 void *argp1 = 0 ;
41018 int res1 = 0 ;
41019 PyObject *swig_obj[1] ;
41020
41021 if (!args) SWIG_fail;
41022 swig_obj[0] = args;
41023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41024 if (!SWIG_IsOK(res1)) {
41025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
41026 }
41027 arg1 = reinterpret_cast< wxWindow * >(argp1);
41028 {
41029 PyThreadState* __tstate = wxPyBeginAllowThreads();
41030 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
41031 wxPyEndAllowThreads(__tstate);
41032 if (PyErr_Occurred()) SWIG_fail;
41033 }
41034 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
41035 return resultobj;
41036 fail:
41037 return NULL;
41038 }
41039
41040
41041 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41042 PyObject *resultobj = 0;
41043 wxWindow *arg1 = (wxWindow *) 0 ;
41044 bool arg2 ;
41045 void *argp1 = 0 ;
41046 int res1 = 0 ;
41047 bool val2 ;
41048 int ecode2 = 0 ;
41049 PyObject * obj0 = 0 ;
41050 PyObject * obj1 = 0 ;
41051 char * kwnames[] = {
41052 (char *) "self",(char *) "autoLayout", NULL
41053 };
41054
41055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
41056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41057 if (!SWIG_IsOK(res1)) {
41058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
41059 }
41060 arg1 = reinterpret_cast< wxWindow * >(argp1);
41061 ecode2 = SWIG_AsVal_bool(obj1, &val2);
41062 if (!SWIG_IsOK(ecode2)) {
41063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
41064 }
41065 arg2 = static_cast< bool >(val2);
41066 {
41067 PyThreadState* __tstate = wxPyBeginAllowThreads();
41068 (arg1)->SetAutoLayout(arg2);
41069 wxPyEndAllowThreads(__tstate);
41070 if (PyErr_Occurred()) SWIG_fail;
41071 }
41072 resultobj = SWIG_Py_Void();
41073 return resultobj;
41074 fail:
41075 return NULL;
41076 }
41077
41078
41079 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41080 PyObject *resultobj = 0;
41081 wxWindow *arg1 = (wxWindow *) 0 ;
41082 bool result;
41083 void *argp1 = 0 ;
41084 int res1 = 0 ;
41085 PyObject *swig_obj[1] ;
41086
41087 if (!args) SWIG_fail;
41088 swig_obj[0] = args;
41089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41090 if (!SWIG_IsOK(res1)) {
41091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
41092 }
41093 arg1 = reinterpret_cast< wxWindow * >(argp1);
41094 {
41095 PyThreadState* __tstate = wxPyBeginAllowThreads();
41096 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
41097 wxPyEndAllowThreads(__tstate);
41098 if (PyErr_Occurred()) SWIG_fail;
41099 }
41100 {
41101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41102 }
41103 return resultobj;
41104 fail:
41105 return NULL;
41106 }
41107
41108
41109 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41110 PyObject *resultobj = 0;
41111 wxWindow *arg1 = (wxWindow *) 0 ;
41112 bool result;
41113 void *argp1 = 0 ;
41114 int res1 = 0 ;
41115 PyObject *swig_obj[1] ;
41116
41117 if (!args) SWIG_fail;
41118 swig_obj[0] = args;
41119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41120 if (!SWIG_IsOK(res1)) {
41121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
41122 }
41123 arg1 = reinterpret_cast< wxWindow * >(argp1);
41124 {
41125 PyThreadState* __tstate = wxPyBeginAllowThreads();
41126 result = (bool)(arg1)->Layout();
41127 wxPyEndAllowThreads(__tstate);
41128 if (PyErr_Occurred()) SWIG_fail;
41129 }
41130 {
41131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41132 }
41133 return resultobj;
41134 fail:
41135 return NULL;
41136 }
41137
41138
41139 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41140 PyObject *resultobj = 0;
41141 wxWindow *arg1 = (wxWindow *) 0 ;
41142 wxSizer *arg2 = (wxSizer *) 0 ;
41143 bool arg3 = (bool) true ;
41144 void *argp1 = 0 ;
41145 int res1 = 0 ;
41146 int res2 = 0 ;
41147 bool val3 ;
41148 int ecode3 = 0 ;
41149 PyObject * obj0 = 0 ;
41150 PyObject * obj1 = 0 ;
41151 PyObject * obj2 = 0 ;
41152 char * kwnames[] = {
41153 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41154 };
41155
41156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41158 if (!SWIG_IsOK(res1)) {
41159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41160 }
41161 arg1 = reinterpret_cast< wxWindow * >(argp1);
41162 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41163 if (!SWIG_IsOK(res2)) {
41164 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41165 }
41166 if (obj2) {
41167 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41168 if (!SWIG_IsOK(ecode3)) {
41169 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
41170 }
41171 arg3 = static_cast< bool >(val3);
41172 }
41173 {
41174 PyThreadState* __tstate = wxPyBeginAllowThreads();
41175 (arg1)->SetSizer(arg2,arg3);
41176 wxPyEndAllowThreads(__tstate);
41177 if (PyErr_Occurred()) SWIG_fail;
41178 }
41179 resultobj = SWIG_Py_Void();
41180 return resultobj;
41181 fail:
41182 return NULL;
41183 }
41184
41185
41186 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41187 PyObject *resultobj = 0;
41188 wxWindow *arg1 = (wxWindow *) 0 ;
41189 wxSizer *arg2 = (wxSizer *) 0 ;
41190 bool arg3 = (bool) true ;
41191 void *argp1 = 0 ;
41192 int res1 = 0 ;
41193 int res2 = 0 ;
41194 bool val3 ;
41195 int ecode3 = 0 ;
41196 PyObject * obj0 = 0 ;
41197 PyObject * obj1 = 0 ;
41198 PyObject * obj2 = 0 ;
41199 char * kwnames[] = {
41200 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41201 };
41202
41203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41205 if (!SWIG_IsOK(res1)) {
41206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
41207 }
41208 arg1 = reinterpret_cast< wxWindow * >(argp1);
41209 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41210 if (!SWIG_IsOK(res2)) {
41211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
41212 }
41213 if (obj2) {
41214 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41215 if (!SWIG_IsOK(ecode3)) {
41216 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
41217 }
41218 arg3 = static_cast< bool >(val3);
41219 }
41220 {
41221 PyThreadState* __tstate = wxPyBeginAllowThreads();
41222 (arg1)->SetSizerAndFit(arg2,arg3);
41223 wxPyEndAllowThreads(__tstate);
41224 if (PyErr_Occurred()) SWIG_fail;
41225 }
41226 resultobj = SWIG_Py_Void();
41227 return resultobj;
41228 fail:
41229 return NULL;
41230 }
41231
41232
41233 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41234 PyObject *resultobj = 0;
41235 wxWindow *arg1 = (wxWindow *) 0 ;
41236 wxSizer *result = 0 ;
41237 void *argp1 = 0 ;
41238 int res1 = 0 ;
41239 PyObject *swig_obj[1] ;
41240
41241 if (!args) SWIG_fail;
41242 swig_obj[0] = args;
41243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41244 if (!SWIG_IsOK(res1)) {
41245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41246 }
41247 arg1 = reinterpret_cast< wxWindow * >(argp1);
41248 {
41249 PyThreadState* __tstate = wxPyBeginAllowThreads();
41250 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
41251 wxPyEndAllowThreads(__tstate);
41252 if (PyErr_Occurred()) SWIG_fail;
41253 }
41254 {
41255 resultobj = wxPyMake_wxObject(result, (bool)0);
41256 }
41257 return resultobj;
41258 fail:
41259 return NULL;
41260 }
41261
41262
41263 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41264 PyObject *resultobj = 0;
41265 wxWindow *arg1 = (wxWindow *) 0 ;
41266 wxSizer *arg2 = (wxSizer *) 0 ;
41267 void *argp1 = 0 ;
41268 int res1 = 0 ;
41269 void *argp2 = 0 ;
41270 int res2 = 0 ;
41271 PyObject * obj0 = 0 ;
41272 PyObject * obj1 = 0 ;
41273 char * kwnames[] = {
41274 (char *) "self",(char *) "sizer", NULL
41275 };
41276
41277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
41278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41279 if (!SWIG_IsOK(res1)) {
41280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41281 }
41282 arg1 = reinterpret_cast< wxWindow * >(argp1);
41283 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
41284 if (!SWIG_IsOK(res2)) {
41285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41286 }
41287 arg2 = reinterpret_cast< wxSizer * >(argp2);
41288 {
41289 PyThreadState* __tstate = wxPyBeginAllowThreads();
41290 (arg1)->SetContainingSizer(arg2);
41291 wxPyEndAllowThreads(__tstate);
41292 if (PyErr_Occurred()) SWIG_fail;
41293 }
41294 resultobj = SWIG_Py_Void();
41295 return resultobj;
41296 fail:
41297 return NULL;
41298 }
41299
41300
41301 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41302 PyObject *resultobj = 0;
41303 wxWindow *arg1 = (wxWindow *) 0 ;
41304 wxSizer *result = 0 ;
41305 void *argp1 = 0 ;
41306 int res1 = 0 ;
41307 PyObject *swig_obj[1] ;
41308
41309 if (!args) SWIG_fail;
41310 swig_obj[0] = args;
41311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41312 if (!SWIG_IsOK(res1)) {
41313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41314 }
41315 arg1 = reinterpret_cast< wxWindow * >(argp1);
41316 {
41317 PyThreadState* __tstate = wxPyBeginAllowThreads();
41318 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
41319 wxPyEndAllowThreads(__tstate);
41320 if (PyErr_Occurred()) SWIG_fail;
41321 }
41322 {
41323 resultobj = wxPyMake_wxObject(result, (bool)0);
41324 }
41325 return resultobj;
41326 fail:
41327 return NULL;
41328 }
41329
41330
41331 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41332 PyObject *resultobj = 0;
41333 wxWindow *arg1 = (wxWindow *) 0 ;
41334 void *argp1 = 0 ;
41335 int res1 = 0 ;
41336 PyObject *swig_obj[1] ;
41337
41338 if (!args) SWIG_fail;
41339 swig_obj[0] = args;
41340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41341 if (!SWIG_IsOK(res1)) {
41342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
41343 }
41344 arg1 = reinterpret_cast< wxWindow * >(argp1);
41345 {
41346 PyThreadState* __tstate = wxPyBeginAllowThreads();
41347 (arg1)->InheritAttributes();
41348 wxPyEndAllowThreads(__tstate);
41349 if (PyErr_Occurred()) SWIG_fail;
41350 }
41351 resultobj = SWIG_Py_Void();
41352 return resultobj;
41353 fail:
41354 return NULL;
41355 }
41356
41357
41358 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41359 PyObject *resultobj = 0;
41360 wxWindow *arg1 = (wxWindow *) 0 ;
41361 bool result;
41362 void *argp1 = 0 ;
41363 int res1 = 0 ;
41364 PyObject *swig_obj[1] ;
41365
41366 if (!args) SWIG_fail;
41367 swig_obj[0] = args;
41368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41369 if (!SWIG_IsOK(res1)) {
41370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41371 }
41372 arg1 = reinterpret_cast< wxWindow * >(argp1);
41373 {
41374 PyThreadState* __tstate = wxPyBeginAllowThreads();
41375 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41376 wxPyEndAllowThreads(__tstate);
41377 if (PyErr_Occurred()) SWIG_fail;
41378 }
41379 {
41380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41381 }
41382 return resultobj;
41383 fail:
41384 return NULL;
41385 }
41386
41387
41388 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41389 PyObject *resultobj = 0;
41390 wxWindow *arg1 = (wxWindow *) 0 ;
41391 bool result;
41392 void *argp1 = 0 ;
41393 int res1 = 0 ;
41394 PyObject *swig_obj[1] ;
41395
41396 if (!args) SWIG_fail;
41397 swig_obj[0] = args;
41398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41399 if (!SWIG_IsOK(res1)) {
41400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41401 }
41402 arg1 = reinterpret_cast< wxWindow * >(argp1);
41403 {
41404 PyThreadState* __tstate = wxPyBeginAllowThreads();
41405 result = (bool)(arg1)->CanSetTransparent();
41406 wxPyEndAllowThreads(__tstate);
41407 if (PyErr_Occurred()) SWIG_fail;
41408 }
41409 {
41410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41411 }
41412 return resultobj;
41413 fail:
41414 return NULL;
41415 }
41416
41417
41418 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41419 PyObject *resultobj = 0;
41420 wxWindow *arg1 = (wxWindow *) 0 ;
41421 byte arg2 ;
41422 bool result;
41423 void *argp1 = 0 ;
41424 int res1 = 0 ;
41425 unsigned char val2 ;
41426 int ecode2 = 0 ;
41427 PyObject * obj0 = 0 ;
41428 PyObject * obj1 = 0 ;
41429 char * kwnames[] = {
41430 (char *) "self",(char *) "alpha", NULL
41431 };
41432
41433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41435 if (!SWIG_IsOK(res1)) {
41436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41437 }
41438 arg1 = reinterpret_cast< wxWindow * >(argp1);
41439 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41440 if (!SWIG_IsOK(ecode2)) {
41441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41442 }
41443 arg2 = static_cast< byte >(val2);
41444 {
41445 PyThreadState* __tstate = wxPyBeginAllowThreads();
41446 result = (bool)(arg1)->SetTransparent(arg2);
41447 wxPyEndAllowThreads(__tstate);
41448 if (PyErr_Occurred()) SWIG_fail;
41449 }
41450 {
41451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41452 }
41453 return resultobj;
41454 fail:
41455 return NULL;
41456 }
41457
41458
41459 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41460 PyObject *obj;
41461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41462 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41463 return SWIG_Py_Void();
41464 }
41465
41466 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41467 return SWIG_Python_InitShadowInstance(args);
41468 }
41469
41470 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41471 PyObject *resultobj = 0;
41472 long arg1 ;
41473 wxWindow *arg2 = (wxWindow *) NULL ;
41474 wxWindow *result = 0 ;
41475 long val1 ;
41476 int ecode1 = 0 ;
41477 void *argp2 = 0 ;
41478 int res2 = 0 ;
41479 PyObject * obj0 = 0 ;
41480 PyObject * obj1 = 0 ;
41481 char * kwnames[] = {
41482 (char *) "id",(char *) "parent", NULL
41483 };
41484
41485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41486 ecode1 = SWIG_AsVal_long(obj0, &val1);
41487 if (!SWIG_IsOK(ecode1)) {
41488 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41489 }
41490 arg1 = static_cast< long >(val1);
41491 if (obj1) {
41492 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41493 if (!SWIG_IsOK(res2)) {
41494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41495 }
41496 arg2 = reinterpret_cast< wxWindow * >(argp2);
41497 }
41498 {
41499 if (!wxPyCheckForApp()) SWIG_fail;
41500 PyThreadState* __tstate = wxPyBeginAllowThreads();
41501 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41502 wxPyEndAllowThreads(__tstate);
41503 if (PyErr_Occurred()) SWIG_fail;
41504 }
41505 {
41506 resultobj = wxPyMake_wxObject(result, 0);
41507 }
41508 return resultobj;
41509 fail:
41510 return NULL;
41511 }
41512
41513
41514 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41515 PyObject *resultobj = 0;
41516 wxString *arg1 = 0 ;
41517 wxWindow *arg2 = (wxWindow *) NULL ;
41518 wxWindow *result = 0 ;
41519 bool temp1 = false ;
41520 void *argp2 = 0 ;
41521 int res2 = 0 ;
41522 PyObject * obj0 = 0 ;
41523 PyObject * obj1 = 0 ;
41524 char * kwnames[] = {
41525 (char *) "name",(char *) "parent", NULL
41526 };
41527
41528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41529 {
41530 arg1 = wxString_in_helper(obj0);
41531 if (arg1 == NULL) SWIG_fail;
41532 temp1 = true;
41533 }
41534 if (obj1) {
41535 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41536 if (!SWIG_IsOK(res2)) {
41537 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41538 }
41539 arg2 = reinterpret_cast< wxWindow * >(argp2);
41540 }
41541 {
41542 if (!wxPyCheckForApp()) SWIG_fail;
41543 PyThreadState* __tstate = wxPyBeginAllowThreads();
41544 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41545 wxPyEndAllowThreads(__tstate);
41546 if (PyErr_Occurred()) SWIG_fail;
41547 }
41548 {
41549 resultobj = wxPyMake_wxObject(result, 0);
41550 }
41551 {
41552 if (temp1)
41553 delete arg1;
41554 }
41555 return resultobj;
41556 fail:
41557 {
41558 if (temp1)
41559 delete arg1;
41560 }
41561 return NULL;
41562 }
41563
41564
41565 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41566 PyObject *resultobj = 0;
41567 wxString *arg1 = 0 ;
41568 wxWindow *arg2 = (wxWindow *) NULL ;
41569 wxWindow *result = 0 ;
41570 bool temp1 = false ;
41571 void *argp2 = 0 ;
41572 int res2 = 0 ;
41573 PyObject * obj0 = 0 ;
41574 PyObject * obj1 = 0 ;
41575 char * kwnames[] = {
41576 (char *) "label",(char *) "parent", NULL
41577 };
41578
41579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41580 {
41581 arg1 = wxString_in_helper(obj0);
41582 if (arg1 == NULL) SWIG_fail;
41583 temp1 = true;
41584 }
41585 if (obj1) {
41586 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41587 if (!SWIG_IsOK(res2)) {
41588 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41589 }
41590 arg2 = reinterpret_cast< wxWindow * >(argp2);
41591 }
41592 {
41593 if (!wxPyCheckForApp()) SWIG_fail;
41594 PyThreadState* __tstate = wxPyBeginAllowThreads();
41595 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41596 wxPyEndAllowThreads(__tstate);
41597 if (PyErr_Occurred()) SWIG_fail;
41598 }
41599 {
41600 resultobj = wxPyMake_wxObject(result, 0);
41601 }
41602 {
41603 if (temp1)
41604 delete arg1;
41605 }
41606 return resultobj;
41607 fail:
41608 {
41609 if (temp1)
41610 delete arg1;
41611 }
41612 return NULL;
41613 }
41614
41615
41616 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41617 PyObject *resultobj = 0;
41618 wxWindow *arg1 = (wxWindow *) 0 ;
41619 unsigned long arg2 ;
41620 wxWindow *result = 0 ;
41621 void *argp1 = 0 ;
41622 int res1 = 0 ;
41623 unsigned long val2 ;
41624 int ecode2 = 0 ;
41625 PyObject * obj0 = 0 ;
41626 PyObject * obj1 = 0 ;
41627 char * kwnames[] = {
41628 (char *) "parent",(char *) "_hWnd", NULL
41629 };
41630
41631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41633 if (!SWIG_IsOK(res1)) {
41634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41635 }
41636 arg1 = reinterpret_cast< wxWindow * >(argp1);
41637 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41638 if (!SWIG_IsOK(ecode2)) {
41639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41640 }
41641 arg2 = static_cast< unsigned long >(val2);
41642 {
41643 if (!wxPyCheckForApp()) SWIG_fail;
41644 PyThreadState* __tstate = wxPyBeginAllowThreads();
41645 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41646 wxPyEndAllowThreads(__tstate);
41647 if (PyErr_Occurred()) SWIG_fail;
41648 }
41649 {
41650 resultobj = wxPyMake_wxObject(result, 0);
41651 }
41652 return resultobj;
41653 fail:
41654 return NULL;
41655 }
41656
41657
41658 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41659 PyObject *resultobj = 0;
41660 PyObject *result = 0 ;
41661
41662 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41663 {
41664 PyThreadState* __tstate = wxPyBeginAllowThreads();
41665 result = (PyObject *)GetTopLevelWindows();
41666 wxPyEndAllowThreads(__tstate);
41667 if (PyErr_Occurred()) SWIG_fail;
41668 }
41669 resultobj = result;
41670 return resultobj;
41671 fail:
41672 return NULL;
41673 }
41674
41675
41676 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41677 PyObject *resultobj = 0;
41678 wxValidator *result = 0 ;
41679
41680 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41681 {
41682 PyThreadState* __tstate = wxPyBeginAllowThreads();
41683 result = (wxValidator *)new wxValidator();
41684 wxPyEndAllowThreads(__tstate);
41685 if (PyErr_Occurred()) SWIG_fail;
41686 }
41687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41688 return resultobj;
41689 fail:
41690 return NULL;
41691 }
41692
41693
41694 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41695 PyObject *resultobj = 0;
41696 wxValidator *arg1 = (wxValidator *) 0 ;
41697 wxValidator *result = 0 ;
41698 void *argp1 = 0 ;
41699 int res1 = 0 ;
41700 PyObject *swig_obj[1] ;
41701
41702 if (!args) SWIG_fail;
41703 swig_obj[0] = args;
41704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41705 if (!SWIG_IsOK(res1)) {
41706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41707 }
41708 arg1 = reinterpret_cast< wxValidator * >(argp1);
41709 {
41710 PyThreadState* __tstate = wxPyBeginAllowThreads();
41711 result = (wxValidator *)(arg1)->Clone();
41712 wxPyEndAllowThreads(__tstate);
41713 if (PyErr_Occurred()) SWIG_fail;
41714 }
41715 {
41716 resultobj = wxPyMake_wxObject(result, 0);
41717 }
41718 return resultobj;
41719 fail:
41720 return NULL;
41721 }
41722
41723
41724 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41725 PyObject *resultobj = 0;
41726 wxValidator *arg1 = (wxValidator *) 0 ;
41727 wxWindow *arg2 = (wxWindow *) 0 ;
41728 bool result;
41729 void *argp1 = 0 ;
41730 int res1 = 0 ;
41731 void *argp2 = 0 ;
41732 int res2 = 0 ;
41733 PyObject * obj0 = 0 ;
41734 PyObject * obj1 = 0 ;
41735 char * kwnames[] = {
41736 (char *) "self",(char *) "parent", NULL
41737 };
41738
41739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41741 if (!SWIG_IsOK(res1)) {
41742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41743 }
41744 arg1 = reinterpret_cast< wxValidator * >(argp1);
41745 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41746 if (!SWIG_IsOK(res2)) {
41747 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41748 }
41749 arg2 = reinterpret_cast< wxWindow * >(argp2);
41750 {
41751 PyThreadState* __tstate = wxPyBeginAllowThreads();
41752 result = (bool)(arg1)->Validate(arg2);
41753 wxPyEndAllowThreads(__tstate);
41754 if (PyErr_Occurred()) SWIG_fail;
41755 }
41756 {
41757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41758 }
41759 return resultobj;
41760 fail:
41761 return NULL;
41762 }
41763
41764
41765 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41766 PyObject *resultobj = 0;
41767 wxValidator *arg1 = (wxValidator *) 0 ;
41768 bool result;
41769 void *argp1 = 0 ;
41770 int res1 = 0 ;
41771 PyObject *swig_obj[1] ;
41772
41773 if (!args) SWIG_fail;
41774 swig_obj[0] = args;
41775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41776 if (!SWIG_IsOK(res1)) {
41777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41778 }
41779 arg1 = reinterpret_cast< wxValidator * >(argp1);
41780 {
41781 PyThreadState* __tstate = wxPyBeginAllowThreads();
41782 result = (bool)(arg1)->TransferToWindow();
41783 wxPyEndAllowThreads(__tstate);
41784 if (PyErr_Occurred()) SWIG_fail;
41785 }
41786 {
41787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41788 }
41789 return resultobj;
41790 fail:
41791 return NULL;
41792 }
41793
41794
41795 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41796 PyObject *resultobj = 0;
41797 wxValidator *arg1 = (wxValidator *) 0 ;
41798 bool result;
41799 void *argp1 = 0 ;
41800 int res1 = 0 ;
41801 PyObject *swig_obj[1] ;
41802
41803 if (!args) SWIG_fail;
41804 swig_obj[0] = args;
41805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41806 if (!SWIG_IsOK(res1)) {
41807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41808 }
41809 arg1 = reinterpret_cast< wxValidator * >(argp1);
41810 {
41811 PyThreadState* __tstate = wxPyBeginAllowThreads();
41812 result = (bool)(arg1)->TransferFromWindow();
41813 wxPyEndAllowThreads(__tstate);
41814 if (PyErr_Occurred()) SWIG_fail;
41815 }
41816 {
41817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41818 }
41819 return resultobj;
41820 fail:
41821 return NULL;
41822 }
41823
41824
41825 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41826 PyObject *resultobj = 0;
41827 wxValidator *arg1 = (wxValidator *) 0 ;
41828 wxWindow *result = 0 ;
41829 void *argp1 = 0 ;
41830 int res1 = 0 ;
41831 PyObject *swig_obj[1] ;
41832
41833 if (!args) SWIG_fail;
41834 swig_obj[0] = args;
41835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41836 if (!SWIG_IsOK(res1)) {
41837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41838 }
41839 arg1 = reinterpret_cast< wxValidator * >(argp1);
41840 {
41841 PyThreadState* __tstate = wxPyBeginAllowThreads();
41842 result = (wxWindow *)(arg1)->GetWindow();
41843 wxPyEndAllowThreads(__tstate);
41844 if (PyErr_Occurred()) SWIG_fail;
41845 }
41846 {
41847 resultobj = wxPyMake_wxObject(result, 0);
41848 }
41849 return resultobj;
41850 fail:
41851 return NULL;
41852 }
41853
41854
41855 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41856 PyObject *resultobj = 0;
41857 wxValidator *arg1 = (wxValidator *) 0 ;
41858 wxWindow *arg2 = (wxWindow *) 0 ;
41859 void *argp1 = 0 ;
41860 int res1 = 0 ;
41861 void *argp2 = 0 ;
41862 int res2 = 0 ;
41863 PyObject * obj0 = 0 ;
41864 PyObject * obj1 = 0 ;
41865 char * kwnames[] = {
41866 (char *) "self",(char *) "window", NULL
41867 };
41868
41869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41871 if (!SWIG_IsOK(res1)) {
41872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41873 }
41874 arg1 = reinterpret_cast< wxValidator * >(argp1);
41875 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41876 if (!SWIG_IsOK(res2)) {
41877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41878 }
41879 arg2 = reinterpret_cast< wxWindow * >(argp2);
41880 {
41881 PyThreadState* __tstate = wxPyBeginAllowThreads();
41882 (arg1)->SetWindow(arg2);
41883 wxPyEndAllowThreads(__tstate);
41884 if (PyErr_Occurred()) SWIG_fail;
41885 }
41886 resultobj = SWIG_Py_Void();
41887 return resultobj;
41888 fail:
41889 return NULL;
41890 }
41891
41892
41893 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41894 PyObject *resultobj = 0;
41895 bool result;
41896
41897 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41898 {
41899 PyThreadState* __tstate = wxPyBeginAllowThreads();
41900 result = (bool)wxValidator::IsSilent();
41901 wxPyEndAllowThreads(__tstate);
41902 if (PyErr_Occurred()) SWIG_fail;
41903 }
41904 {
41905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41906 }
41907 return resultobj;
41908 fail:
41909 return NULL;
41910 }
41911
41912
41913 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41914 PyObject *resultobj = 0;
41915 int arg1 = (int) true ;
41916 int val1 ;
41917 int ecode1 = 0 ;
41918 PyObject * obj0 = 0 ;
41919 char * kwnames[] = {
41920 (char *) "doIt", NULL
41921 };
41922
41923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41924 if (obj0) {
41925 ecode1 = SWIG_AsVal_int(obj0, &val1);
41926 if (!SWIG_IsOK(ecode1)) {
41927 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41928 }
41929 arg1 = static_cast< int >(val1);
41930 }
41931 {
41932 PyThreadState* __tstate = wxPyBeginAllowThreads();
41933 wxValidator::SetBellOnError(arg1);
41934 wxPyEndAllowThreads(__tstate);
41935 if (PyErr_Occurred()) SWIG_fail;
41936 }
41937 resultobj = SWIG_Py_Void();
41938 return resultobj;
41939 fail:
41940 return NULL;
41941 }
41942
41943
41944 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41945 PyObject *obj;
41946 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41947 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41948 return SWIG_Py_Void();
41949 }
41950
41951 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41952 return SWIG_Python_InitShadowInstance(args);
41953 }
41954
41955 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41956 PyObject *resultobj = 0;
41957 wxPyValidator *result = 0 ;
41958
41959 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41960 {
41961 PyThreadState* __tstate = wxPyBeginAllowThreads();
41962 result = (wxPyValidator *)new wxPyValidator();
41963 wxPyEndAllowThreads(__tstate);
41964 if (PyErr_Occurred()) SWIG_fail;
41965 }
41966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41967 return resultobj;
41968 fail:
41969 return NULL;
41970 }
41971
41972
41973 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41974 PyObject *resultobj = 0;
41975 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41976 PyObject *arg2 = (PyObject *) 0 ;
41977 PyObject *arg3 = (PyObject *) 0 ;
41978 int arg4 = (int) 1 ;
41979 void *argp1 = 0 ;
41980 int res1 = 0 ;
41981 int val4 ;
41982 int ecode4 = 0 ;
41983 PyObject * obj0 = 0 ;
41984 PyObject * obj1 = 0 ;
41985 PyObject * obj2 = 0 ;
41986 PyObject * obj3 = 0 ;
41987 char * kwnames[] = {
41988 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41989 };
41990
41991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41993 if (!SWIG_IsOK(res1)) {
41994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41995 }
41996 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41997 arg2 = obj1;
41998 arg3 = obj2;
41999 if (obj3) {
42000 ecode4 = SWIG_AsVal_int(obj3, &val4);
42001 if (!SWIG_IsOK(ecode4)) {
42002 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
42003 }
42004 arg4 = static_cast< int >(val4);
42005 }
42006 {
42007 PyThreadState* __tstate = wxPyBeginAllowThreads();
42008 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
42009 wxPyEndAllowThreads(__tstate);
42010 if (PyErr_Occurred()) SWIG_fail;
42011 }
42012 resultobj = SWIG_Py_Void();
42013 return resultobj;
42014 fail:
42015 return NULL;
42016 }
42017
42018
42019 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42020 PyObject *obj;
42021 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42022 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
42023 return SWIG_Py_Void();
42024 }
42025
42026 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42027 return SWIG_Python_InitShadowInstance(args);
42028 }
42029
42030 SWIGINTERN int DefaultValidator_set(PyObject *) {
42031 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
42032 return 1;
42033 }
42034
42035
42036 SWIGINTERN PyObject *DefaultValidator_get(void) {
42037 PyObject *pyobj = 0;
42038
42039 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
42040 return pyobj;
42041 }
42042
42043
42044 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42045 PyObject *resultobj = 0;
42046 wxString const &arg1_defvalue = wxPyEmptyString ;
42047 wxString *arg1 = (wxString *) &arg1_defvalue ;
42048 long arg2 = (long) 0 ;
42049 wxMenu *result = 0 ;
42050 bool temp1 = false ;
42051 long val2 ;
42052 int ecode2 = 0 ;
42053 PyObject * obj0 = 0 ;
42054 PyObject * obj1 = 0 ;
42055 char * kwnames[] = {
42056 (char *) "title",(char *) "style", NULL
42057 };
42058
42059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
42060 if (obj0) {
42061 {
42062 arg1 = wxString_in_helper(obj0);
42063 if (arg1 == NULL) SWIG_fail;
42064 temp1 = true;
42065 }
42066 }
42067 if (obj1) {
42068 ecode2 = SWIG_AsVal_long(obj1, &val2);
42069 if (!SWIG_IsOK(ecode2)) {
42070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
42071 }
42072 arg2 = static_cast< long >(val2);
42073 }
42074 {
42075 if (!wxPyCheckForApp()) SWIG_fail;
42076 PyThreadState* __tstate = wxPyBeginAllowThreads();
42077 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
42078 wxPyEndAllowThreads(__tstate);
42079 if (PyErr_Occurred()) SWIG_fail;
42080 }
42081 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
42082 {
42083 if (temp1)
42084 delete arg1;
42085 }
42086 return resultobj;
42087 fail:
42088 {
42089 if (temp1)
42090 delete arg1;
42091 }
42092 return NULL;
42093 }
42094
42095
42096 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42097 PyObject *resultobj = 0;
42098 wxMenu *arg1 = (wxMenu *) 0 ;
42099 int arg2 ;
42100 wxString const &arg3_defvalue = wxPyEmptyString ;
42101 wxString *arg3 = (wxString *) &arg3_defvalue ;
42102 wxString const &arg4_defvalue = wxPyEmptyString ;
42103 wxString *arg4 = (wxString *) &arg4_defvalue ;
42104 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42105 wxMenuItem *result = 0 ;
42106 void *argp1 = 0 ;
42107 int res1 = 0 ;
42108 int val2 ;
42109 int ecode2 = 0 ;
42110 bool temp3 = false ;
42111 bool temp4 = false ;
42112 int val5 ;
42113 int ecode5 = 0 ;
42114 PyObject * obj0 = 0 ;
42115 PyObject * obj1 = 0 ;
42116 PyObject * obj2 = 0 ;
42117 PyObject * obj3 = 0 ;
42118 PyObject * obj4 = 0 ;
42119 char * kwnames[] = {
42120 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42121 };
42122
42123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42125 if (!SWIG_IsOK(res1)) {
42126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
42127 }
42128 arg1 = reinterpret_cast< wxMenu * >(argp1);
42129 ecode2 = SWIG_AsVal_int(obj1, &val2);
42130 if (!SWIG_IsOK(ecode2)) {
42131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
42132 }
42133 arg2 = static_cast< int >(val2);
42134 if (obj2) {
42135 {
42136 arg3 = wxString_in_helper(obj2);
42137 if (arg3 == NULL) SWIG_fail;
42138 temp3 = true;
42139 }
42140 }
42141 if (obj3) {
42142 {
42143 arg4 = wxString_in_helper(obj3);
42144 if (arg4 == NULL) SWIG_fail;
42145 temp4 = true;
42146 }
42147 }
42148 if (obj4) {
42149 ecode5 = SWIG_AsVal_int(obj4, &val5);
42150 if (!SWIG_IsOK(ecode5)) {
42151 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
42152 }
42153 arg5 = static_cast< wxItemKind >(val5);
42154 }
42155 {
42156 PyThreadState* __tstate = wxPyBeginAllowThreads();
42157 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42158 wxPyEndAllowThreads(__tstate);
42159 if (PyErr_Occurred()) SWIG_fail;
42160 }
42161 {
42162 resultobj = wxPyMake_wxObject(result, (bool)0);
42163 }
42164 {
42165 if (temp3)
42166 delete arg3;
42167 }
42168 {
42169 if (temp4)
42170 delete arg4;
42171 }
42172 return resultobj;
42173 fail:
42174 {
42175 if (temp3)
42176 delete arg3;
42177 }
42178 {
42179 if (temp4)
42180 delete arg4;
42181 }
42182 return NULL;
42183 }
42184
42185
42186 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42187 PyObject *resultobj = 0;
42188 wxMenu *arg1 = (wxMenu *) 0 ;
42189 wxMenuItem *result = 0 ;
42190 void *argp1 = 0 ;
42191 int res1 = 0 ;
42192 PyObject *swig_obj[1] ;
42193
42194 if (!args) SWIG_fail;
42195 swig_obj[0] = args;
42196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42197 if (!SWIG_IsOK(res1)) {
42198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42199 }
42200 arg1 = reinterpret_cast< wxMenu * >(argp1);
42201 {
42202 PyThreadState* __tstate = wxPyBeginAllowThreads();
42203 result = (wxMenuItem *)(arg1)->AppendSeparator();
42204 wxPyEndAllowThreads(__tstate);
42205 if (PyErr_Occurred()) SWIG_fail;
42206 }
42207 {
42208 resultobj = wxPyMake_wxObject(result, (bool)0);
42209 }
42210 return resultobj;
42211 fail:
42212 return NULL;
42213 }
42214
42215
42216 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42217 PyObject *resultobj = 0;
42218 wxMenu *arg1 = (wxMenu *) 0 ;
42219 int arg2 ;
42220 wxString *arg3 = 0 ;
42221 wxString const &arg4_defvalue = wxPyEmptyString ;
42222 wxString *arg4 = (wxString *) &arg4_defvalue ;
42223 wxMenuItem *result = 0 ;
42224 void *argp1 = 0 ;
42225 int res1 = 0 ;
42226 int val2 ;
42227 int ecode2 = 0 ;
42228 bool temp3 = false ;
42229 bool temp4 = false ;
42230 PyObject * obj0 = 0 ;
42231 PyObject * obj1 = 0 ;
42232 PyObject * obj2 = 0 ;
42233 PyObject * obj3 = 0 ;
42234 char * kwnames[] = {
42235 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42236 };
42237
42238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42240 if (!SWIG_IsOK(res1)) {
42241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42242 }
42243 arg1 = reinterpret_cast< wxMenu * >(argp1);
42244 ecode2 = SWIG_AsVal_int(obj1, &val2);
42245 if (!SWIG_IsOK(ecode2)) {
42246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
42247 }
42248 arg2 = static_cast< int >(val2);
42249 {
42250 arg3 = wxString_in_helper(obj2);
42251 if (arg3 == NULL) SWIG_fail;
42252 temp3 = true;
42253 }
42254 if (obj3) {
42255 {
42256 arg4 = wxString_in_helper(obj3);
42257 if (arg4 == NULL) SWIG_fail;
42258 temp4 = true;
42259 }
42260 }
42261 {
42262 PyThreadState* __tstate = wxPyBeginAllowThreads();
42263 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42264 wxPyEndAllowThreads(__tstate);
42265 if (PyErr_Occurred()) SWIG_fail;
42266 }
42267 {
42268 resultobj = wxPyMake_wxObject(result, (bool)0);
42269 }
42270 {
42271 if (temp3)
42272 delete arg3;
42273 }
42274 {
42275 if (temp4)
42276 delete arg4;
42277 }
42278 return resultobj;
42279 fail:
42280 {
42281 if (temp3)
42282 delete arg3;
42283 }
42284 {
42285 if (temp4)
42286 delete arg4;
42287 }
42288 return NULL;
42289 }
42290
42291
42292 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42293 PyObject *resultobj = 0;
42294 wxMenu *arg1 = (wxMenu *) 0 ;
42295 int arg2 ;
42296 wxString *arg3 = 0 ;
42297 wxString const &arg4_defvalue = wxPyEmptyString ;
42298 wxString *arg4 = (wxString *) &arg4_defvalue ;
42299 wxMenuItem *result = 0 ;
42300 void *argp1 = 0 ;
42301 int res1 = 0 ;
42302 int val2 ;
42303 int ecode2 = 0 ;
42304 bool temp3 = false ;
42305 bool temp4 = false ;
42306 PyObject * obj0 = 0 ;
42307 PyObject * obj1 = 0 ;
42308 PyObject * obj2 = 0 ;
42309 PyObject * obj3 = 0 ;
42310 char * kwnames[] = {
42311 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42312 };
42313
42314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42316 if (!SWIG_IsOK(res1)) {
42317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42318 }
42319 arg1 = reinterpret_cast< wxMenu * >(argp1);
42320 ecode2 = SWIG_AsVal_int(obj1, &val2);
42321 if (!SWIG_IsOK(ecode2)) {
42322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
42323 }
42324 arg2 = static_cast< int >(val2);
42325 {
42326 arg3 = wxString_in_helper(obj2);
42327 if (arg3 == NULL) SWIG_fail;
42328 temp3 = true;
42329 }
42330 if (obj3) {
42331 {
42332 arg4 = wxString_in_helper(obj3);
42333 if (arg4 == NULL) SWIG_fail;
42334 temp4 = true;
42335 }
42336 }
42337 {
42338 PyThreadState* __tstate = wxPyBeginAllowThreads();
42339 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42340 wxPyEndAllowThreads(__tstate);
42341 if (PyErr_Occurred()) SWIG_fail;
42342 }
42343 {
42344 resultobj = wxPyMake_wxObject(result, (bool)0);
42345 }
42346 {
42347 if (temp3)
42348 delete arg3;
42349 }
42350 {
42351 if (temp4)
42352 delete arg4;
42353 }
42354 return resultobj;
42355 fail:
42356 {
42357 if (temp3)
42358 delete arg3;
42359 }
42360 {
42361 if (temp4)
42362 delete arg4;
42363 }
42364 return NULL;
42365 }
42366
42367
42368 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42369 PyObject *resultobj = 0;
42370 wxMenu *arg1 = (wxMenu *) 0 ;
42371 int arg2 ;
42372 wxString *arg3 = 0 ;
42373 wxMenu *arg4 = (wxMenu *) 0 ;
42374 wxString const &arg5_defvalue = wxPyEmptyString ;
42375 wxString *arg5 = (wxString *) &arg5_defvalue ;
42376 wxMenuItem *result = 0 ;
42377 void *argp1 = 0 ;
42378 int res1 = 0 ;
42379 int val2 ;
42380 int ecode2 = 0 ;
42381 bool temp3 = false ;
42382 void *argp4 = 0 ;
42383 int res4 = 0 ;
42384 bool temp5 = false ;
42385 PyObject * obj0 = 0 ;
42386 PyObject * obj1 = 0 ;
42387 PyObject * obj2 = 0 ;
42388 PyObject * obj3 = 0 ;
42389 PyObject * obj4 = 0 ;
42390 char * kwnames[] = {
42391 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42392 };
42393
42394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42396 if (!SWIG_IsOK(res1)) {
42397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42398 }
42399 arg1 = reinterpret_cast< wxMenu * >(argp1);
42400 ecode2 = SWIG_AsVal_int(obj1, &val2);
42401 if (!SWIG_IsOK(ecode2)) {
42402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42403 }
42404 arg2 = static_cast< int >(val2);
42405 {
42406 arg3 = wxString_in_helper(obj2);
42407 if (arg3 == NULL) SWIG_fail;
42408 temp3 = true;
42409 }
42410 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42411 if (!SWIG_IsOK(res4)) {
42412 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42413 }
42414 arg4 = reinterpret_cast< wxMenu * >(argp4);
42415 if (obj4) {
42416 {
42417 arg5 = wxString_in_helper(obj4);
42418 if (arg5 == NULL) SWIG_fail;
42419 temp5 = true;
42420 }
42421 }
42422 {
42423 PyThreadState* __tstate = wxPyBeginAllowThreads();
42424 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42425 wxPyEndAllowThreads(__tstate);
42426 if (PyErr_Occurred()) SWIG_fail;
42427 }
42428 {
42429 resultobj = wxPyMake_wxObject(result, (bool)0);
42430 }
42431 {
42432 if (temp3)
42433 delete arg3;
42434 }
42435 {
42436 if (temp5)
42437 delete arg5;
42438 }
42439 return resultobj;
42440 fail:
42441 {
42442 if (temp3)
42443 delete arg3;
42444 }
42445 {
42446 if (temp5)
42447 delete arg5;
42448 }
42449 return NULL;
42450 }
42451
42452
42453 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42454 PyObject *resultobj = 0;
42455 wxMenu *arg1 = (wxMenu *) 0 ;
42456 wxMenu *arg2 = (wxMenu *) 0 ;
42457 wxString *arg3 = 0 ;
42458 wxString const &arg4_defvalue = wxPyEmptyString ;
42459 wxString *arg4 = (wxString *) &arg4_defvalue ;
42460 wxMenuItem *result = 0 ;
42461 void *argp1 = 0 ;
42462 int res1 = 0 ;
42463 void *argp2 = 0 ;
42464 int res2 = 0 ;
42465 bool temp3 = false ;
42466 bool temp4 = false ;
42467 PyObject * obj0 = 0 ;
42468 PyObject * obj1 = 0 ;
42469 PyObject * obj2 = 0 ;
42470 PyObject * obj3 = 0 ;
42471 char * kwnames[] = {
42472 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42473 };
42474
42475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42477 if (!SWIG_IsOK(res1)) {
42478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42479 }
42480 arg1 = reinterpret_cast< wxMenu * >(argp1);
42481 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42482 if (!SWIG_IsOK(res2)) {
42483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42484 }
42485 arg2 = reinterpret_cast< wxMenu * >(argp2);
42486 {
42487 arg3 = wxString_in_helper(obj2);
42488 if (arg3 == NULL) SWIG_fail;
42489 temp3 = true;
42490 }
42491 if (obj3) {
42492 {
42493 arg4 = wxString_in_helper(obj3);
42494 if (arg4 == NULL) SWIG_fail;
42495 temp4 = true;
42496 }
42497 }
42498 {
42499 PyThreadState* __tstate = wxPyBeginAllowThreads();
42500 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42501 wxPyEndAllowThreads(__tstate);
42502 if (PyErr_Occurred()) SWIG_fail;
42503 }
42504 {
42505 resultobj = wxPyMake_wxObject(result, (bool)0);
42506 }
42507 {
42508 if (temp3)
42509 delete arg3;
42510 }
42511 {
42512 if (temp4)
42513 delete arg4;
42514 }
42515 return resultobj;
42516 fail:
42517 {
42518 if (temp3)
42519 delete arg3;
42520 }
42521 {
42522 if (temp4)
42523 delete arg4;
42524 }
42525 return NULL;
42526 }
42527
42528
42529 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42530 PyObject *resultobj = 0;
42531 wxMenu *arg1 = (wxMenu *) 0 ;
42532 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42533 wxMenuItem *result = 0 ;
42534 void *argp1 = 0 ;
42535 int res1 = 0 ;
42536 int res2 = 0 ;
42537 PyObject * obj0 = 0 ;
42538 PyObject * obj1 = 0 ;
42539 char * kwnames[] = {
42540 (char *) "self",(char *) "item", NULL
42541 };
42542
42543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42545 if (!SWIG_IsOK(res1)) {
42546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42547 }
42548 arg1 = reinterpret_cast< wxMenu * >(argp1);
42549 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42550 if (!SWIG_IsOK(res2)) {
42551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42552 }
42553 {
42554 PyThreadState* __tstate = wxPyBeginAllowThreads();
42555 result = (wxMenuItem *)(arg1)->Append(arg2);
42556 wxPyEndAllowThreads(__tstate);
42557 if (PyErr_Occurred()) SWIG_fail;
42558 }
42559 {
42560 resultobj = wxPyMake_wxObject(result, (bool)0);
42561 }
42562 return resultobj;
42563 fail:
42564 return NULL;
42565 }
42566
42567
42568 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42569 PyObject *resultobj = 0;
42570 wxMenu *arg1 = (wxMenu *) 0 ;
42571 size_t arg2 ;
42572 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42573 wxMenuItem *result = 0 ;
42574 void *argp1 = 0 ;
42575 int res1 = 0 ;
42576 size_t val2 ;
42577 int ecode2 = 0 ;
42578 int res3 = 0 ;
42579 PyObject * obj0 = 0 ;
42580 PyObject * obj1 = 0 ;
42581 PyObject * obj2 = 0 ;
42582 char * kwnames[] = {
42583 (char *) "self",(char *) "pos",(char *) "item", NULL
42584 };
42585
42586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42588 if (!SWIG_IsOK(res1)) {
42589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42590 }
42591 arg1 = reinterpret_cast< wxMenu * >(argp1);
42592 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42593 if (!SWIG_IsOK(ecode2)) {
42594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42595 }
42596 arg2 = static_cast< size_t >(val2);
42597 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42598 if (!SWIG_IsOK(res3)) {
42599 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42600 }
42601 {
42602 PyThreadState* __tstate = wxPyBeginAllowThreads();
42603 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42604 wxPyEndAllowThreads(__tstate);
42605 if (PyErr_Occurred()) SWIG_fail;
42606 }
42607 {
42608 resultobj = wxPyMake_wxObject(result, (bool)0);
42609 }
42610 return resultobj;
42611 fail:
42612 return NULL;
42613 }
42614
42615
42616 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42617 PyObject *resultobj = 0;
42618 wxMenu *arg1 = (wxMenu *) 0 ;
42619 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42620 wxMenuItem *result = 0 ;
42621 void *argp1 = 0 ;
42622 int res1 = 0 ;
42623 int res2 = 0 ;
42624 PyObject * obj0 = 0 ;
42625 PyObject * obj1 = 0 ;
42626 char * kwnames[] = {
42627 (char *) "self",(char *) "item", NULL
42628 };
42629
42630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42632 if (!SWIG_IsOK(res1)) {
42633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42634 }
42635 arg1 = reinterpret_cast< wxMenu * >(argp1);
42636 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42637 if (!SWIG_IsOK(res2)) {
42638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42639 }
42640 {
42641 PyThreadState* __tstate = wxPyBeginAllowThreads();
42642 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42643 wxPyEndAllowThreads(__tstate);
42644 if (PyErr_Occurred()) SWIG_fail;
42645 }
42646 {
42647 resultobj = wxPyMake_wxObject(result, (bool)0);
42648 }
42649 return resultobj;
42650 fail:
42651 return NULL;
42652 }
42653
42654
42655 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42656 PyObject *resultobj = 0;
42657 wxMenu *arg1 = (wxMenu *) 0 ;
42658 void *argp1 = 0 ;
42659 int res1 = 0 ;
42660 PyObject *swig_obj[1] ;
42661
42662 if (!args) SWIG_fail;
42663 swig_obj[0] = args;
42664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42665 if (!SWIG_IsOK(res1)) {
42666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42667 }
42668 arg1 = reinterpret_cast< wxMenu * >(argp1);
42669 {
42670 PyThreadState* __tstate = wxPyBeginAllowThreads();
42671 (arg1)->Break();
42672 wxPyEndAllowThreads(__tstate);
42673 if (PyErr_Occurred()) SWIG_fail;
42674 }
42675 resultobj = SWIG_Py_Void();
42676 return resultobj;
42677 fail:
42678 return NULL;
42679 }
42680
42681
42682 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42683 PyObject *resultobj = 0;
42684 wxMenu *arg1 = (wxMenu *) 0 ;
42685 size_t arg2 ;
42686 int arg3 ;
42687 wxString const &arg4_defvalue = wxPyEmptyString ;
42688 wxString *arg4 = (wxString *) &arg4_defvalue ;
42689 wxString const &arg5_defvalue = wxPyEmptyString ;
42690 wxString *arg5 = (wxString *) &arg5_defvalue ;
42691 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42692 wxMenuItem *result = 0 ;
42693 void *argp1 = 0 ;
42694 int res1 = 0 ;
42695 size_t val2 ;
42696 int ecode2 = 0 ;
42697 int val3 ;
42698 int ecode3 = 0 ;
42699 bool temp4 = false ;
42700 bool temp5 = false ;
42701 int val6 ;
42702 int ecode6 = 0 ;
42703 PyObject * obj0 = 0 ;
42704 PyObject * obj1 = 0 ;
42705 PyObject * obj2 = 0 ;
42706 PyObject * obj3 = 0 ;
42707 PyObject * obj4 = 0 ;
42708 PyObject * obj5 = 0 ;
42709 char * kwnames[] = {
42710 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42711 };
42712
42713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42715 if (!SWIG_IsOK(res1)) {
42716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42717 }
42718 arg1 = reinterpret_cast< wxMenu * >(argp1);
42719 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42720 if (!SWIG_IsOK(ecode2)) {
42721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42722 }
42723 arg2 = static_cast< size_t >(val2);
42724 ecode3 = SWIG_AsVal_int(obj2, &val3);
42725 if (!SWIG_IsOK(ecode3)) {
42726 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42727 }
42728 arg3 = static_cast< int >(val3);
42729 if (obj3) {
42730 {
42731 arg4 = wxString_in_helper(obj3);
42732 if (arg4 == NULL) SWIG_fail;
42733 temp4 = true;
42734 }
42735 }
42736 if (obj4) {
42737 {
42738 arg5 = wxString_in_helper(obj4);
42739 if (arg5 == NULL) SWIG_fail;
42740 temp5 = true;
42741 }
42742 }
42743 if (obj5) {
42744 ecode6 = SWIG_AsVal_int(obj5, &val6);
42745 if (!SWIG_IsOK(ecode6)) {
42746 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42747 }
42748 arg6 = static_cast< wxItemKind >(val6);
42749 }
42750 {
42751 PyThreadState* __tstate = wxPyBeginAllowThreads();
42752 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42753 wxPyEndAllowThreads(__tstate);
42754 if (PyErr_Occurred()) SWIG_fail;
42755 }
42756 {
42757 resultobj = wxPyMake_wxObject(result, (bool)0);
42758 }
42759 {
42760 if (temp4)
42761 delete arg4;
42762 }
42763 {
42764 if (temp5)
42765 delete arg5;
42766 }
42767 return resultobj;
42768 fail:
42769 {
42770 if (temp4)
42771 delete arg4;
42772 }
42773 {
42774 if (temp5)
42775 delete arg5;
42776 }
42777 return NULL;
42778 }
42779
42780
42781 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42782 PyObject *resultobj = 0;
42783 wxMenu *arg1 = (wxMenu *) 0 ;
42784 size_t arg2 ;
42785 wxMenuItem *result = 0 ;
42786 void *argp1 = 0 ;
42787 int res1 = 0 ;
42788 size_t val2 ;
42789 int ecode2 = 0 ;
42790 PyObject * obj0 = 0 ;
42791 PyObject * obj1 = 0 ;
42792 char * kwnames[] = {
42793 (char *) "self",(char *) "pos", NULL
42794 };
42795
42796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42798 if (!SWIG_IsOK(res1)) {
42799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42800 }
42801 arg1 = reinterpret_cast< wxMenu * >(argp1);
42802 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42803 if (!SWIG_IsOK(ecode2)) {
42804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42805 }
42806 arg2 = static_cast< size_t >(val2);
42807 {
42808 PyThreadState* __tstate = wxPyBeginAllowThreads();
42809 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42810 wxPyEndAllowThreads(__tstate);
42811 if (PyErr_Occurred()) SWIG_fail;
42812 }
42813 {
42814 resultobj = wxPyMake_wxObject(result, (bool)0);
42815 }
42816 return resultobj;
42817 fail:
42818 return NULL;
42819 }
42820
42821
42822 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42823 PyObject *resultobj = 0;
42824 wxMenu *arg1 = (wxMenu *) 0 ;
42825 size_t arg2 ;
42826 int arg3 ;
42827 wxString *arg4 = 0 ;
42828 wxString const &arg5_defvalue = wxPyEmptyString ;
42829 wxString *arg5 = (wxString *) &arg5_defvalue ;
42830 wxMenuItem *result = 0 ;
42831 void *argp1 = 0 ;
42832 int res1 = 0 ;
42833 size_t val2 ;
42834 int ecode2 = 0 ;
42835 int val3 ;
42836 int ecode3 = 0 ;
42837 bool temp4 = false ;
42838 bool temp5 = false ;
42839 PyObject * obj0 = 0 ;
42840 PyObject * obj1 = 0 ;
42841 PyObject * obj2 = 0 ;
42842 PyObject * obj3 = 0 ;
42843 PyObject * obj4 = 0 ;
42844 char * kwnames[] = {
42845 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42846 };
42847
42848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42850 if (!SWIG_IsOK(res1)) {
42851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42852 }
42853 arg1 = reinterpret_cast< wxMenu * >(argp1);
42854 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42855 if (!SWIG_IsOK(ecode2)) {
42856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42857 }
42858 arg2 = static_cast< size_t >(val2);
42859 ecode3 = SWIG_AsVal_int(obj2, &val3);
42860 if (!SWIG_IsOK(ecode3)) {
42861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42862 }
42863 arg3 = static_cast< int >(val3);
42864 {
42865 arg4 = wxString_in_helper(obj3);
42866 if (arg4 == NULL) SWIG_fail;
42867 temp4 = true;
42868 }
42869 if (obj4) {
42870 {
42871 arg5 = wxString_in_helper(obj4);
42872 if (arg5 == NULL) SWIG_fail;
42873 temp5 = true;
42874 }
42875 }
42876 {
42877 PyThreadState* __tstate = wxPyBeginAllowThreads();
42878 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42879 wxPyEndAllowThreads(__tstate);
42880 if (PyErr_Occurred()) SWIG_fail;
42881 }
42882 {
42883 resultobj = wxPyMake_wxObject(result, (bool)0);
42884 }
42885 {
42886 if (temp4)
42887 delete arg4;
42888 }
42889 {
42890 if (temp5)
42891 delete arg5;
42892 }
42893 return resultobj;
42894 fail:
42895 {
42896 if (temp4)
42897 delete arg4;
42898 }
42899 {
42900 if (temp5)
42901 delete arg5;
42902 }
42903 return NULL;
42904 }
42905
42906
42907 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42908 PyObject *resultobj = 0;
42909 wxMenu *arg1 = (wxMenu *) 0 ;
42910 size_t arg2 ;
42911 int arg3 ;
42912 wxString *arg4 = 0 ;
42913 wxString const &arg5_defvalue = wxPyEmptyString ;
42914 wxString *arg5 = (wxString *) &arg5_defvalue ;
42915 wxMenuItem *result = 0 ;
42916 void *argp1 = 0 ;
42917 int res1 = 0 ;
42918 size_t val2 ;
42919 int ecode2 = 0 ;
42920 int val3 ;
42921 int ecode3 = 0 ;
42922 bool temp4 = false ;
42923 bool temp5 = false ;
42924 PyObject * obj0 = 0 ;
42925 PyObject * obj1 = 0 ;
42926 PyObject * obj2 = 0 ;
42927 PyObject * obj3 = 0 ;
42928 PyObject * obj4 = 0 ;
42929 char * kwnames[] = {
42930 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42931 };
42932
42933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42935 if (!SWIG_IsOK(res1)) {
42936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42937 }
42938 arg1 = reinterpret_cast< wxMenu * >(argp1);
42939 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42940 if (!SWIG_IsOK(ecode2)) {
42941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42942 }
42943 arg2 = static_cast< size_t >(val2);
42944 ecode3 = SWIG_AsVal_int(obj2, &val3);
42945 if (!SWIG_IsOK(ecode3)) {
42946 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42947 }
42948 arg3 = static_cast< int >(val3);
42949 {
42950 arg4 = wxString_in_helper(obj3);
42951 if (arg4 == NULL) SWIG_fail;
42952 temp4 = true;
42953 }
42954 if (obj4) {
42955 {
42956 arg5 = wxString_in_helper(obj4);
42957 if (arg5 == NULL) SWIG_fail;
42958 temp5 = true;
42959 }
42960 }
42961 {
42962 PyThreadState* __tstate = wxPyBeginAllowThreads();
42963 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42964 wxPyEndAllowThreads(__tstate);
42965 if (PyErr_Occurred()) SWIG_fail;
42966 }
42967 {
42968 resultobj = wxPyMake_wxObject(result, (bool)0);
42969 }
42970 {
42971 if (temp4)
42972 delete arg4;
42973 }
42974 {
42975 if (temp5)
42976 delete arg5;
42977 }
42978 return resultobj;
42979 fail:
42980 {
42981 if (temp4)
42982 delete arg4;
42983 }
42984 {
42985 if (temp5)
42986 delete arg5;
42987 }
42988 return NULL;
42989 }
42990
42991
42992 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42993 PyObject *resultobj = 0;
42994 wxMenu *arg1 = (wxMenu *) 0 ;
42995 size_t arg2 ;
42996 int arg3 ;
42997 wxString *arg4 = 0 ;
42998 wxMenu *arg5 = (wxMenu *) 0 ;
42999 wxString const &arg6_defvalue = wxPyEmptyString ;
43000 wxString *arg6 = (wxString *) &arg6_defvalue ;
43001 wxMenuItem *result = 0 ;
43002 void *argp1 = 0 ;
43003 int res1 = 0 ;
43004 size_t val2 ;
43005 int ecode2 = 0 ;
43006 int val3 ;
43007 int ecode3 = 0 ;
43008 bool temp4 = false ;
43009 void *argp5 = 0 ;
43010 int res5 = 0 ;
43011 bool temp6 = false ;
43012 PyObject * obj0 = 0 ;
43013 PyObject * obj1 = 0 ;
43014 PyObject * obj2 = 0 ;
43015 PyObject * obj3 = 0 ;
43016 PyObject * obj4 = 0 ;
43017 PyObject * obj5 = 0 ;
43018 char * kwnames[] = {
43019 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43020 };
43021
43022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43024 if (!SWIG_IsOK(res1)) {
43025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43026 }
43027 arg1 = reinterpret_cast< wxMenu * >(argp1);
43028 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43029 if (!SWIG_IsOK(ecode2)) {
43030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
43031 }
43032 arg2 = static_cast< size_t >(val2);
43033 ecode3 = SWIG_AsVal_int(obj2, &val3);
43034 if (!SWIG_IsOK(ecode3)) {
43035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
43036 }
43037 arg3 = static_cast< int >(val3);
43038 {
43039 arg4 = wxString_in_helper(obj3);
43040 if (arg4 == NULL) SWIG_fail;
43041 temp4 = true;
43042 }
43043 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
43044 if (!SWIG_IsOK(res5)) {
43045 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
43046 }
43047 arg5 = reinterpret_cast< wxMenu * >(argp5);
43048 if (obj5) {
43049 {
43050 arg6 = wxString_in_helper(obj5);
43051 if (arg6 == NULL) SWIG_fail;
43052 temp6 = true;
43053 }
43054 }
43055 {
43056 PyThreadState* __tstate = wxPyBeginAllowThreads();
43057 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
43058 wxPyEndAllowThreads(__tstate);
43059 if (PyErr_Occurred()) SWIG_fail;
43060 }
43061 {
43062 resultobj = wxPyMake_wxObject(result, (bool)0);
43063 }
43064 {
43065 if (temp4)
43066 delete arg4;
43067 }
43068 {
43069 if (temp6)
43070 delete arg6;
43071 }
43072 return resultobj;
43073 fail:
43074 {
43075 if (temp4)
43076 delete arg4;
43077 }
43078 {
43079 if (temp6)
43080 delete arg6;
43081 }
43082 return NULL;
43083 }
43084
43085
43086 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43087 PyObject *resultobj = 0;
43088 wxMenu *arg1 = (wxMenu *) 0 ;
43089 int arg2 ;
43090 wxString const &arg3_defvalue = wxPyEmptyString ;
43091 wxString *arg3 = (wxString *) &arg3_defvalue ;
43092 wxString const &arg4_defvalue = wxPyEmptyString ;
43093 wxString *arg4 = (wxString *) &arg4_defvalue ;
43094 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43095 wxMenuItem *result = 0 ;
43096 void *argp1 = 0 ;
43097 int res1 = 0 ;
43098 int val2 ;
43099 int ecode2 = 0 ;
43100 bool temp3 = false ;
43101 bool temp4 = false ;
43102 int val5 ;
43103 int ecode5 = 0 ;
43104 PyObject * obj0 = 0 ;
43105 PyObject * obj1 = 0 ;
43106 PyObject * obj2 = 0 ;
43107 PyObject * obj3 = 0 ;
43108 PyObject * obj4 = 0 ;
43109 char * kwnames[] = {
43110 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
43111 };
43112
43113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43115 if (!SWIG_IsOK(res1)) {
43116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
43117 }
43118 arg1 = reinterpret_cast< wxMenu * >(argp1);
43119 ecode2 = SWIG_AsVal_int(obj1, &val2);
43120 if (!SWIG_IsOK(ecode2)) {
43121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
43122 }
43123 arg2 = static_cast< int >(val2);
43124 if (obj2) {
43125 {
43126 arg3 = wxString_in_helper(obj2);
43127 if (arg3 == NULL) SWIG_fail;
43128 temp3 = true;
43129 }
43130 }
43131 if (obj3) {
43132 {
43133 arg4 = wxString_in_helper(obj3);
43134 if (arg4 == NULL) SWIG_fail;
43135 temp4 = true;
43136 }
43137 }
43138 if (obj4) {
43139 ecode5 = SWIG_AsVal_int(obj4, &val5);
43140 if (!SWIG_IsOK(ecode5)) {
43141 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
43142 }
43143 arg5 = static_cast< wxItemKind >(val5);
43144 }
43145 {
43146 PyThreadState* __tstate = wxPyBeginAllowThreads();
43147 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
43148 wxPyEndAllowThreads(__tstate);
43149 if (PyErr_Occurred()) SWIG_fail;
43150 }
43151 {
43152 resultobj = wxPyMake_wxObject(result, (bool)0);
43153 }
43154 {
43155 if (temp3)
43156 delete arg3;
43157 }
43158 {
43159 if (temp4)
43160 delete arg4;
43161 }
43162 return resultobj;
43163 fail:
43164 {
43165 if (temp3)
43166 delete arg3;
43167 }
43168 {
43169 if (temp4)
43170 delete arg4;
43171 }
43172 return NULL;
43173 }
43174
43175
43176 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43177 PyObject *resultobj = 0;
43178 wxMenu *arg1 = (wxMenu *) 0 ;
43179 wxMenuItem *result = 0 ;
43180 void *argp1 = 0 ;
43181 int res1 = 0 ;
43182 PyObject *swig_obj[1] ;
43183
43184 if (!args) SWIG_fail;
43185 swig_obj[0] = args;
43186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43187 if (!SWIG_IsOK(res1)) {
43188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
43189 }
43190 arg1 = reinterpret_cast< wxMenu * >(argp1);
43191 {
43192 PyThreadState* __tstate = wxPyBeginAllowThreads();
43193 result = (wxMenuItem *)(arg1)->PrependSeparator();
43194 wxPyEndAllowThreads(__tstate);
43195 if (PyErr_Occurred()) SWIG_fail;
43196 }
43197 {
43198 resultobj = wxPyMake_wxObject(result, (bool)0);
43199 }
43200 return resultobj;
43201 fail:
43202 return NULL;
43203 }
43204
43205
43206 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43207 PyObject *resultobj = 0;
43208 wxMenu *arg1 = (wxMenu *) 0 ;
43209 int arg2 ;
43210 wxString *arg3 = 0 ;
43211 wxString const &arg4_defvalue = wxPyEmptyString ;
43212 wxString *arg4 = (wxString *) &arg4_defvalue ;
43213 wxMenuItem *result = 0 ;
43214 void *argp1 = 0 ;
43215 int res1 = 0 ;
43216 int val2 ;
43217 int ecode2 = 0 ;
43218 bool temp3 = false ;
43219 bool temp4 = false ;
43220 PyObject * obj0 = 0 ;
43221 PyObject * obj1 = 0 ;
43222 PyObject * obj2 = 0 ;
43223 PyObject * obj3 = 0 ;
43224 char * kwnames[] = {
43225 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43226 };
43227
43228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43230 if (!SWIG_IsOK(res1)) {
43231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43232 }
43233 arg1 = reinterpret_cast< wxMenu * >(argp1);
43234 ecode2 = SWIG_AsVal_int(obj1, &val2);
43235 if (!SWIG_IsOK(ecode2)) {
43236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
43237 }
43238 arg2 = static_cast< int >(val2);
43239 {
43240 arg3 = wxString_in_helper(obj2);
43241 if (arg3 == NULL) SWIG_fail;
43242 temp3 = true;
43243 }
43244 if (obj3) {
43245 {
43246 arg4 = wxString_in_helper(obj3);
43247 if (arg4 == NULL) SWIG_fail;
43248 temp4 = true;
43249 }
43250 }
43251 {
43252 PyThreadState* __tstate = wxPyBeginAllowThreads();
43253 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43254 wxPyEndAllowThreads(__tstate);
43255 if (PyErr_Occurred()) SWIG_fail;
43256 }
43257 {
43258 resultobj = wxPyMake_wxObject(result, (bool)0);
43259 }
43260 {
43261 if (temp3)
43262 delete arg3;
43263 }
43264 {
43265 if (temp4)
43266 delete arg4;
43267 }
43268 return resultobj;
43269 fail:
43270 {
43271 if (temp3)
43272 delete arg3;
43273 }
43274 {
43275 if (temp4)
43276 delete arg4;
43277 }
43278 return NULL;
43279 }
43280
43281
43282 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43283 PyObject *resultobj = 0;
43284 wxMenu *arg1 = (wxMenu *) 0 ;
43285 int arg2 ;
43286 wxString *arg3 = 0 ;
43287 wxString const &arg4_defvalue = wxPyEmptyString ;
43288 wxString *arg4 = (wxString *) &arg4_defvalue ;
43289 wxMenuItem *result = 0 ;
43290 void *argp1 = 0 ;
43291 int res1 = 0 ;
43292 int val2 ;
43293 int ecode2 = 0 ;
43294 bool temp3 = false ;
43295 bool temp4 = false ;
43296 PyObject * obj0 = 0 ;
43297 PyObject * obj1 = 0 ;
43298 PyObject * obj2 = 0 ;
43299 PyObject * obj3 = 0 ;
43300 char * kwnames[] = {
43301 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43302 };
43303
43304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43306 if (!SWIG_IsOK(res1)) {
43307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43308 }
43309 arg1 = reinterpret_cast< wxMenu * >(argp1);
43310 ecode2 = SWIG_AsVal_int(obj1, &val2);
43311 if (!SWIG_IsOK(ecode2)) {
43312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
43313 }
43314 arg2 = static_cast< int >(val2);
43315 {
43316 arg3 = wxString_in_helper(obj2);
43317 if (arg3 == NULL) SWIG_fail;
43318 temp3 = true;
43319 }
43320 if (obj3) {
43321 {
43322 arg4 = wxString_in_helper(obj3);
43323 if (arg4 == NULL) SWIG_fail;
43324 temp4 = true;
43325 }
43326 }
43327 {
43328 PyThreadState* __tstate = wxPyBeginAllowThreads();
43329 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43330 wxPyEndAllowThreads(__tstate);
43331 if (PyErr_Occurred()) SWIG_fail;
43332 }
43333 {
43334 resultobj = wxPyMake_wxObject(result, (bool)0);
43335 }
43336 {
43337 if (temp3)
43338 delete arg3;
43339 }
43340 {
43341 if (temp4)
43342 delete arg4;
43343 }
43344 return resultobj;
43345 fail:
43346 {
43347 if (temp3)
43348 delete arg3;
43349 }
43350 {
43351 if (temp4)
43352 delete arg4;
43353 }
43354 return NULL;
43355 }
43356
43357
43358 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43359 PyObject *resultobj = 0;
43360 wxMenu *arg1 = (wxMenu *) 0 ;
43361 int arg2 ;
43362 wxString *arg3 = 0 ;
43363 wxMenu *arg4 = (wxMenu *) 0 ;
43364 wxString const &arg5_defvalue = wxPyEmptyString ;
43365 wxString *arg5 = (wxString *) &arg5_defvalue ;
43366 wxMenuItem *result = 0 ;
43367 void *argp1 = 0 ;
43368 int res1 = 0 ;
43369 int val2 ;
43370 int ecode2 = 0 ;
43371 bool temp3 = false ;
43372 void *argp4 = 0 ;
43373 int res4 = 0 ;
43374 bool temp5 = false ;
43375 PyObject * obj0 = 0 ;
43376 PyObject * obj1 = 0 ;
43377 PyObject * obj2 = 0 ;
43378 PyObject * obj3 = 0 ;
43379 PyObject * obj4 = 0 ;
43380 char * kwnames[] = {
43381 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43382 };
43383
43384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43386 if (!SWIG_IsOK(res1)) {
43387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43388 }
43389 arg1 = reinterpret_cast< wxMenu * >(argp1);
43390 ecode2 = SWIG_AsVal_int(obj1, &val2);
43391 if (!SWIG_IsOK(ecode2)) {
43392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43393 }
43394 arg2 = static_cast< int >(val2);
43395 {
43396 arg3 = wxString_in_helper(obj2);
43397 if (arg3 == NULL) SWIG_fail;
43398 temp3 = true;
43399 }
43400 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43401 if (!SWIG_IsOK(res4)) {
43402 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43403 }
43404 arg4 = reinterpret_cast< wxMenu * >(argp4);
43405 if (obj4) {
43406 {
43407 arg5 = wxString_in_helper(obj4);
43408 if (arg5 == NULL) SWIG_fail;
43409 temp5 = true;
43410 }
43411 }
43412 {
43413 PyThreadState* __tstate = wxPyBeginAllowThreads();
43414 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43415 wxPyEndAllowThreads(__tstate);
43416 if (PyErr_Occurred()) SWIG_fail;
43417 }
43418 {
43419 resultobj = wxPyMake_wxObject(result, (bool)0);
43420 }
43421 {
43422 if (temp3)
43423 delete arg3;
43424 }
43425 {
43426 if (temp5)
43427 delete arg5;
43428 }
43429 return resultobj;
43430 fail:
43431 {
43432 if (temp3)
43433 delete arg3;
43434 }
43435 {
43436 if (temp5)
43437 delete arg5;
43438 }
43439 return NULL;
43440 }
43441
43442
43443 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43444 PyObject *resultobj = 0;
43445 wxMenu *arg1 = (wxMenu *) 0 ;
43446 int arg2 ;
43447 wxMenuItem *result = 0 ;
43448 void *argp1 = 0 ;
43449 int res1 = 0 ;
43450 int val2 ;
43451 int ecode2 = 0 ;
43452 PyObject * obj0 = 0 ;
43453 PyObject * obj1 = 0 ;
43454 char * kwnames[] = {
43455 (char *) "self",(char *) "id", NULL
43456 };
43457
43458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43460 if (!SWIG_IsOK(res1)) {
43461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43462 }
43463 arg1 = reinterpret_cast< wxMenu * >(argp1);
43464 ecode2 = SWIG_AsVal_int(obj1, &val2);
43465 if (!SWIG_IsOK(ecode2)) {
43466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43467 }
43468 arg2 = static_cast< int >(val2);
43469 {
43470 PyThreadState* __tstate = wxPyBeginAllowThreads();
43471 result = (wxMenuItem *)(arg1)->Remove(arg2);
43472 wxPyEndAllowThreads(__tstate);
43473 if (PyErr_Occurred()) SWIG_fail;
43474 }
43475 {
43476 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43477 }
43478 return resultobj;
43479 fail:
43480 return NULL;
43481 }
43482
43483
43484 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43485 PyObject *resultobj = 0;
43486 wxMenu *arg1 = (wxMenu *) 0 ;
43487 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43488 wxMenuItem *result = 0 ;
43489 void *argp1 = 0 ;
43490 int res1 = 0 ;
43491 void *argp2 = 0 ;
43492 int res2 = 0 ;
43493 PyObject * obj0 = 0 ;
43494 PyObject * obj1 = 0 ;
43495 char * kwnames[] = {
43496 (char *) "self",(char *) "item", NULL
43497 };
43498
43499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43501 if (!SWIG_IsOK(res1)) {
43502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43503 }
43504 arg1 = reinterpret_cast< wxMenu * >(argp1);
43505 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43506 if (!SWIG_IsOK(res2)) {
43507 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43508 }
43509 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43510 {
43511 PyThreadState* __tstate = wxPyBeginAllowThreads();
43512 result = (wxMenuItem *)(arg1)->Remove(arg2);
43513 wxPyEndAllowThreads(__tstate);
43514 if (PyErr_Occurred()) SWIG_fail;
43515 }
43516 {
43517 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43518 }
43519 return resultobj;
43520 fail:
43521 return NULL;
43522 }
43523
43524
43525 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43526 PyObject *resultobj = 0;
43527 wxMenu *arg1 = (wxMenu *) 0 ;
43528 int arg2 ;
43529 bool result;
43530 void *argp1 = 0 ;
43531 int res1 = 0 ;
43532 int val2 ;
43533 int ecode2 = 0 ;
43534 PyObject * obj0 = 0 ;
43535 PyObject * obj1 = 0 ;
43536 char * kwnames[] = {
43537 (char *) "self",(char *) "id", NULL
43538 };
43539
43540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43542 if (!SWIG_IsOK(res1)) {
43543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43544 }
43545 arg1 = reinterpret_cast< wxMenu * >(argp1);
43546 ecode2 = SWIG_AsVal_int(obj1, &val2);
43547 if (!SWIG_IsOK(ecode2)) {
43548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43549 }
43550 arg2 = static_cast< int >(val2);
43551 {
43552 PyThreadState* __tstate = wxPyBeginAllowThreads();
43553 result = (bool)(arg1)->Delete(arg2);
43554 wxPyEndAllowThreads(__tstate);
43555 if (PyErr_Occurred()) SWIG_fail;
43556 }
43557 {
43558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43559 }
43560 return resultobj;
43561 fail:
43562 return NULL;
43563 }
43564
43565
43566 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43567 PyObject *resultobj = 0;
43568 wxMenu *arg1 = (wxMenu *) 0 ;
43569 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43570 bool result;
43571 void *argp1 = 0 ;
43572 int res1 = 0 ;
43573 void *argp2 = 0 ;
43574 int res2 = 0 ;
43575 PyObject * obj0 = 0 ;
43576 PyObject * obj1 = 0 ;
43577 char * kwnames[] = {
43578 (char *) "self",(char *) "item", NULL
43579 };
43580
43581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43583 if (!SWIG_IsOK(res1)) {
43584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43585 }
43586 arg1 = reinterpret_cast< wxMenu * >(argp1);
43587 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43588 if (!SWIG_IsOK(res2)) {
43589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43590 }
43591 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43592 {
43593 PyThreadState* __tstate = wxPyBeginAllowThreads();
43594 result = (bool)(arg1)->Delete(arg2);
43595 wxPyEndAllowThreads(__tstate);
43596 if (PyErr_Occurred()) SWIG_fail;
43597 }
43598 {
43599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43600 }
43601 return resultobj;
43602 fail:
43603 return NULL;
43604 }
43605
43606
43607 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43608 PyObject *resultobj = 0;
43609 wxMenu *arg1 = (wxMenu *) 0 ;
43610 void *argp1 = 0 ;
43611 int res1 = 0 ;
43612 PyObject *swig_obj[1] ;
43613
43614 if (!args) SWIG_fail;
43615 swig_obj[0] = args;
43616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43617 if (!SWIG_IsOK(res1)) {
43618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43619 }
43620 arg1 = reinterpret_cast< wxMenu * >(argp1);
43621 {
43622 PyThreadState* __tstate = wxPyBeginAllowThreads();
43623 wxMenu_Destroy(arg1);
43624 wxPyEndAllowThreads(__tstate);
43625 if (PyErr_Occurred()) SWIG_fail;
43626 }
43627 resultobj = SWIG_Py_Void();
43628 return resultobj;
43629 fail:
43630 return NULL;
43631 }
43632
43633
43634 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43635 PyObject *resultobj = 0;
43636 wxMenu *arg1 = (wxMenu *) 0 ;
43637 int arg2 ;
43638 bool result;
43639 void *argp1 = 0 ;
43640 int res1 = 0 ;
43641 int val2 ;
43642 int ecode2 = 0 ;
43643 PyObject * obj0 = 0 ;
43644 PyObject * obj1 = 0 ;
43645 char * kwnames[] = {
43646 (char *) "self",(char *) "id", NULL
43647 };
43648
43649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43651 if (!SWIG_IsOK(res1)) {
43652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43653 }
43654 arg1 = reinterpret_cast< wxMenu * >(argp1);
43655 ecode2 = SWIG_AsVal_int(obj1, &val2);
43656 if (!SWIG_IsOK(ecode2)) {
43657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43658 }
43659 arg2 = static_cast< int >(val2);
43660 {
43661 PyThreadState* __tstate = wxPyBeginAllowThreads();
43662 result = (bool)(arg1)->Destroy(arg2);
43663 wxPyEndAllowThreads(__tstate);
43664 if (PyErr_Occurred()) SWIG_fail;
43665 }
43666 {
43667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43668 }
43669 return resultobj;
43670 fail:
43671 return NULL;
43672 }
43673
43674
43675 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43676 PyObject *resultobj = 0;
43677 wxMenu *arg1 = (wxMenu *) 0 ;
43678 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43679 bool result;
43680 void *argp1 = 0 ;
43681 int res1 = 0 ;
43682 void *argp2 = 0 ;
43683 int res2 = 0 ;
43684 PyObject * obj0 = 0 ;
43685 PyObject * obj1 = 0 ;
43686 char * kwnames[] = {
43687 (char *) "self",(char *) "item", NULL
43688 };
43689
43690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43692 if (!SWIG_IsOK(res1)) {
43693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43694 }
43695 arg1 = reinterpret_cast< wxMenu * >(argp1);
43696 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43697 if (!SWIG_IsOK(res2)) {
43698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43699 }
43700 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43701 {
43702 PyThreadState* __tstate = wxPyBeginAllowThreads();
43703 result = (bool)(arg1)->Destroy(arg2);
43704 wxPyEndAllowThreads(__tstate);
43705 if (PyErr_Occurred()) SWIG_fail;
43706 }
43707 {
43708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43709 }
43710 return resultobj;
43711 fail:
43712 return NULL;
43713 }
43714
43715
43716 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43717 PyObject *resultobj = 0;
43718 wxMenu *arg1 = (wxMenu *) 0 ;
43719 size_t result;
43720 void *argp1 = 0 ;
43721 int res1 = 0 ;
43722 PyObject *swig_obj[1] ;
43723
43724 if (!args) SWIG_fail;
43725 swig_obj[0] = args;
43726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43727 if (!SWIG_IsOK(res1)) {
43728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43729 }
43730 arg1 = reinterpret_cast< wxMenu * >(argp1);
43731 {
43732 PyThreadState* __tstate = wxPyBeginAllowThreads();
43733 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43734 wxPyEndAllowThreads(__tstate);
43735 if (PyErr_Occurred()) SWIG_fail;
43736 }
43737 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43738 return resultobj;
43739 fail:
43740 return NULL;
43741 }
43742
43743
43744 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43745 PyObject *resultobj = 0;
43746 wxMenu *arg1 = (wxMenu *) 0 ;
43747 PyObject *result = 0 ;
43748 void *argp1 = 0 ;
43749 int res1 = 0 ;
43750 PyObject *swig_obj[1] ;
43751
43752 if (!args) SWIG_fail;
43753 swig_obj[0] = args;
43754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43755 if (!SWIG_IsOK(res1)) {
43756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43757 }
43758 arg1 = reinterpret_cast< wxMenu * >(argp1);
43759 {
43760 PyThreadState* __tstate = wxPyBeginAllowThreads();
43761 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43762 wxPyEndAllowThreads(__tstate);
43763 if (PyErr_Occurred()) SWIG_fail;
43764 }
43765 resultobj = result;
43766 return resultobj;
43767 fail:
43768 return NULL;
43769 }
43770
43771
43772 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43773 PyObject *resultobj = 0;
43774 wxMenu *arg1 = (wxMenu *) 0 ;
43775 wxString *arg2 = 0 ;
43776 int result;
43777 void *argp1 = 0 ;
43778 int res1 = 0 ;
43779 bool temp2 = false ;
43780 PyObject * obj0 = 0 ;
43781 PyObject * obj1 = 0 ;
43782 char * kwnames[] = {
43783 (char *) "self",(char *) "item", NULL
43784 };
43785
43786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43788 if (!SWIG_IsOK(res1)) {
43789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43790 }
43791 arg1 = reinterpret_cast< wxMenu * >(argp1);
43792 {
43793 arg2 = wxString_in_helper(obj1);
43794 if (arg2 == NULL) SWIG_fail;
43795 temp2 = true;
43796 }
43797 {
43798 PyThreadState* __tstate = wxPyBeginAllowThreads();
43799 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43800 wxPyEndAllowThreads(__tstate);
43801 if (PyErr_Occurred()) SWIG_fail;
43802 }
43803 resultobj = SWIG_From_int(static_cast< int >(result));
43804 {
43805 if (temp2)
43806 delete arg2;
43807 }
43808 return resultobj;
43809 fail:
43810 {
43811 if (temp2)
43812 delete arg2;
43813 }
43814 return NULL;
43815 }
43816
43817
43818 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43819 PyObject *resultobj = 0;
43820 wxMenu *arg1 = (wxMenu *) 0 ;
43821 int arg2 ;
43822 wxMenuItem *result = 0 ;
43823 void *argp1 = 0 ;
43824 int res1 = 0 ;
43825 int val2 ;
43826 int ecode2 = 0 ;
43827 PyObject * obj0 = 0 ;
43828 PyObject * obj1 = 0 ;
43829 char * kwnames[] = {
43830 (char *) "self",(char *) "id", NULL
43831 };
43832
43833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43835 if (!SWIG_IsOK(res1)) {
43836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43837 }
43838 arg1 = reinterpret_cast< wxMenu * >(argp1);
43839 ecode2 = SWIG_AsVal_int(obj1, &val2);
43840 if (!SWIG_IsOK(ecode2)) {
43841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43842 }
43843 arg2 = static_cast< int >(val2);
43844 {
43845 PyThreadState* __tstate = wxPyBeginAllowThreads();
43846 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43847 wxPyEndAllowThreads(__tstate);
43848 if (PyErr_Occurred()) SWIG_fail;
43849 }
43850 {
43851 resultobj = wxPyMake_wxObject(result, (bool)0);
43852 }
43853 return resultobj;
43854 fail:
43855 return NULL;
43856 }
43857
43858
43859 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43860 PyObject *resultobj = 0;
43861 wxMenu *arg1 = (wxMenu *) 0 ;
43862 size_t arg2 ;
43863 wxMenuItem *result = 0 ;
43864 void *argp1 = 0 ;
43865 int res1 = 0 ;
43866 size_t val2 ;
43867 int ecode2 = 0 ;
43868 PyObject * obj0 = 0 ;
43869 PyObject * obj1 = 0 ;
43870 char * kwnames[] = {
43871 (char *) "self",(char *) "position", NULL
43872 };
43873
43874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43876 if (!SWIG_IsOK(res1)) {
43877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43878 }
43879 arg1 = reinterpret_cast< wxMenu * >(argp1);
43880 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43881 if (!SWIG_IsOK(ecode2)) {
43882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43883 }
43884 arg2 = static_cast< size_t >(val2);
43885 {
43886 PyThreadState* __tstate = wxPyBeginAllowThreads();
43887 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43888 wxPyEndAllowThreads(__tstate);
43889 if (PyErr_Occurred()) SWIG_fail;
43890 }
43891 {
43892 resultobj = wxPyMake_wxObject(result, (bool)0);
43893 }
43894 return resultobj;
43895 fail:
43896 return NULL;
43897 }
43898
43899
43900 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43901 PyObject *resultobj = 0;
43902 wxMenu *arg1 = (wxMenu *) 0 ;
43903 int arg2 ;
43904 bool arg3 ;
43905 void *argp1 = 0 ;
43906 int res1 = 0 ;
43907 int val2 ;
43908 int ecode2 = 0 ;
43909 bool val3 ;
43910 int ecode3 = 0 ;
43911 PyObject * obj0 = 0 ;
43912 PyObject * obj1 = 0 ;
43913 PyObject * obj2 = 0 ;
43914 char * kwnames[] = {
43915 (char *) "self",(char *) "id",(char *) "enable", NULL
43916 };
43917
43918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43920 if (!SWIG_IsOK(res1)) {
43921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43922 }
43923 arg1 = reinterpret_cast< wxMenu * >(argp1);
43924 ecode2 = SWIG_AsVal_int(obj1, &val2);
43925 if (!SWIG_IsOK(ecode2)) {
43926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43927 }
43928 arg2 = static_cast< int >(val2);
43929 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43930 if (!SWIG_IsOK(ecode3)) {
43931 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43932 }
43933 arg3 = static_cast< bool >(val3);
43934 {
43935 PyThreadState* __tstate = wxPyBeginAllowThreads();
43936 (arg1)->Enable(arg2,arg3);
43937 wxPyEndAllowThreads(__tstate);
43938 if (PyErr_Occurred()) SWIG_fail;
43939 }
43940 resultobj = SWIG_Py_Void();
43941 return resultobj;
43942 fail:
43943 return NULL;
43944 }
43945
43946
43947 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43948 PyObject *resultobj = 0;
43949 wxMenu *arg1 = (wxMenu *) 0 ;
43950 int arg2 ;
43951 bool result;
43952 void *argp1 = 0 ;
43953 int res1 = 0 ;
43954 int val2 ;
43955 int ecode2 = 0 ;
43956 PyObject * obj0 = 0 ;
43957 PyObject * obj1 = 0 ;
43958 char * kwnames[] = {
43959 (char *) "self",(char *) "id", NULL
43960 };
43961
43962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43964 if (!SWIG_IsOK(res1)) {
43965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43966 }
43967 arg1 = reinterpret_cast< wxMenu * >(argp1);
43968 ecode2 = SWIG_AsVal_int(obj1, &val2);
43969 if (!SWIG_IsOK(ecode2)) {
43970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43971 }
43972 arg2 = static_cast< int >(val2);
43973 {
43974 PyThreadState* __tstate = wxPyBeginAllowThreads();
43975 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43976 wxPyEndAllowThreads(__tstate);
43977 if (PyErr_Occurred()) SWIG_fail;
43978 }
43979 {
43980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43981 }
43982 return resultobj;
43983 fail:
43984 return NULL;
43985 }
43986
43987
43988 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43989 PyObject *resultobj = 0;
43990 wxMenu *arg1 = (wxMenu *) 0 ;
43991 int arg2 ;
43992 bool arg3 ;
43993 void *argp1 = 0 ;
43994 int res1 = 0 ;
43995 int val2 ;
43996 int ecode2 = 0 ;
43997 bool val3 ;
43998 int ecode3 = 0 ;
43999 PyObject * obj0 = 0 ;
44000 PyObject * obj1 = 0 ;
44001 PyObject * obj2 = 0 ;
44002 char * kwnames[] = {
44003 (char *) "self",(char *) "id",(char *) "check", NULL
44004 };
44005
44006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44008 if (!SWIG_IsOK(res1)) {
44009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
44010 }
44011 arg1 = reinterpret_cast< wxMenu * >(argp1);
44012 ecode2 = SWIG_AsVal_int(obj1, &val2);
44013 if (!SWIG_IsOK(ecode2)) {
44014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
44015 }
44016 arg2 = static_cast< int >(val2);
44017 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44018 if (!SWIG_IsOK(ecode3)) {
44019 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
44020 }
44021 arg3 = static_cast< bool >(val3);
44022 {
44023 PyThreadState* __tstate = wxPyBeginAllowThreads();
44024 (arg1)->Check(arg2,arg3);
44025 wxPyEndAllowThreads(__tstate);
44026 if (PyErr_Occurred()) SWIG_fail;
44027 }
44028 resultobj = SWIG_Py_Void();
44029 return resultobj;
44030 fail:
44031 return NULL;
44032 }
44033
44034
44035 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44036 PyObject *resultobj = 0;
44037 wxMenu *arg1 = (wxMenu *) 0 ;
44038 int arg2 ;
44039 bool result;
44040 void *argp1 = 0 ;
44041 int res1 = 0 ;
44042 int val2 ;
44043 int ecode2 = 0 ;
44044 PyObject * obj0 = 0 ;
44045 PyObject * obj1 = 0 ;
44046 char * kwnames[] = {
44047 (char *) "self",(char *) "id", NULL
44048 };
44049
44050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
44051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44052 if (!SWIG_IsOK(res1)) {
44053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
44054 }
44055 arg1 = reinterpret_cast< wxMenu * >(argp1);
44056 ecode2 = SWIG_AsVal_int(obj1, &val2);
44057 if (!SWIG_IsOK(ecode2)) {
44058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
44059 }
44060 arg2 = static_cast< int >(val2);
44061 {
44062 PyThreadState* __tstate = wxPyBeginAllowThreads();
44063 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
44064 wxPyEndAllowThreads(__tstate);
44065 if (PyErr_Occurred()) SWIG_fail;
44066 }
44067 {
44068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44069 }
44070 return resultobj;
44071 fail:
44072 return NULL;
44073 }
44074
44075
44076 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44077 PyObject *resultobj = 0;
44078 wxMenu *arg1 = (wxMenu *) 0 ;
44079 int arg2 ;
44080 wxString *arg3 = 0 ;
44081 void *argp1 = 0 ;
44082 int res1 = 0 ;
44083 int val2 ;
44084 int ecode2 = 0 ;
44085 bool temp3 = false ;
44086 PyObject * obj0 = 0 ;
44087 PyObject * obj1 = 0 ;
44088 PyObject * obj2 = 0 ;
44089 char * kwnames[] = {
44090 (char *) "self",(char *) "id",(char *) "label", NULL
44091 };
44092
44093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) 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_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
44097 }
44098 arg1 = reinterpret_cast< wxMenu * >(argp1);
44099 ecode2 = SWIG_AsVal_int(obj1, &val2);
44100 if (!SWIG_IsOK(ecode2)) {
44101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
44102 }
44103 arg2 = static_cast< int >(val2);
44104 {
44105 arg3 = wxString_in_helper(obj2);
44106 if (arg3 == NULL) SWIG_fail;
44107 temp3 = true;
44108 }
44109 {
44110 PyThreadState* __tstate = wxPyBeginAllowThreads();
44111 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
44112 wxPyEndAllowThreads(__tstate);
44113 if (PyErr_Occurred()) SWIG_fail;
44114 }
44115 resultobj = SWIG_Py_Void();
44116 {
44117 if (temp3)
44118 delete arg3;
44119 }
44120 return resultobj;
44121 fail:
44122 {
44123 if (temp3)
44124 delete arg3;
44125 }
44126 return NULL;
44127 }
44128
44129
44130 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44131 PyObject *resultobj = 0;
44132 wxMenu *arg1 = (wxMenu *) 0 ;
44133 int arg2 ;
44134 wxString result;
44135 void *argp1 = 0 ;
44136 int res1 = 0 ;
44137 int val2 ;
44138 int ecode2 = 0 ;
44139 PyObject * obj0 = 0 ;
44140 PyObject * obj1 = 0 ;
44141 char * kwnames[] = {
44142 (char *) "self",(char *) "id", NULL
44143 };
44144
44145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
44146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44147 if (!SWIG_IsOK(res1)) {
44148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
44149 }
44150 arg1 = reinterpret_cast< wxMenu * >(argp1);
44151 ecode2 = SWIG_AsVal_int(obj1, &val2);
44152 if (!SWIG_IsOK(ecode2)) {
44153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
44154 }
44155 arg2 = static_cast< int >(val2);
44156 {
44157 PyThreadState* __tstate = wxPyBeginAllowThreads();
44158 result = ((wxMenu const *)arg1)->GetLabel(arg2);
44159 wxPyEndAllowThreads(__tstate);
44160 if (PyErr_Occurred()) SWIG_fail;
44161 }
44162 {
44163 #if wxUSE_UNICODE
44164 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44165 #else
44166 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44167 #endif
44168 }
44169 return resultobj;
44170 fail:
44171 return NULL;
44172 }
44173
44174
44175 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44176 PyObject *resultobj = 0;
44177 wxMenu *arg1 = (wxMenu *) 0 ;
44178 int arg2 ;
44179 wxString *arg3 = 0 ;
44180 void *argp1 = 0 ;
44181 int res1 = 0 ;
44182 int val2 ;
44183 int ecode2 = 0 ;
44184 bool temp3 = false ;
44185 PyObject * obj0 = 0 ;
44186 PyObject * obj1 = 0 ;
44187 PyObject * obj2 = 0 ;
44188 char * kwnames[] = {
44189 (char *) "self",(char *) "id",(char *) "helpString", NULL
44190 };
44191
44192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44194 if (!SWIG_IsOK(res1)) {
44195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
44196 }
44197 arg1 = reinterpret_cast< wxMenu * >(argp1);
44198 ecode2 = SWIG_AsVal_int(obj1, &val2);
44199 if (!SWIG_IsOK(ecode2)) {
44200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
44201 }
44202 arg2 = static_cast< int >(val2);
44203 {
44204 arg3 = wxString_in_helper(obj2);
44205 if (arg3 == NULL) SWIG_fail;
44206 temp3 = true;
44207 }
44208 {
44209 PyThreadState* __tstate = wxPyBeginAllowThreads();
44210 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
44211 wxPyEndAllowThreads(__tstate);
44212 if (PyErr_Occurred()) SWIG_fail;
44213 }
44214 resultobj = SWIG_Py_Void();
44215 {
44216 if (temp3)
44217 delete arg3;
44218 }
44219 return resultobj;
44220 fail:
44221 {
44222 if (temp3)
44223 delete arg3;
44224 }
44225 return NULL;
44226 }
44227
44228
44229 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44230 PyObject *resultobj = 0;
44231 wxMenu *arg1 = (wxMenu *) 0 ;
44232 int arg2 ;
44233 wxString result;
44234 void *argp1 = 0 ;
44235 int res1 = 0 ;
44236 int val2 ;
44237 int ecode2 = 0 ;
44238 PyObject * obj0 = 0 ;
44239 PyObject * obj1 = 0 ;
44240 char * kwnames[] = {
44241 (char *) "self",(char *) "id", NULL
44242 };
44243
44244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
44245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44246 if (!SWIG_IsOK(res1)) {
44247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
44248 }
44249 arg1 = reinterpret_cast< wxMenu * >(argp1);
44250 ecode2 = SWIG_AsVal_int(obj1, &val2);
44251 if (!SWIG_IsOK(ecode2)) {
44252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
44253 }
44254 arg2 = static_cast< int >(val2);
44255 {
44256 PyThreadState* __tstate = wxPyBeginAllowThreads();
44257 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
44258 wxPyEndAllowThreads(__tstate);
44259 if (PyErr_Occurred()) SWIG_fail;
44260 }
44261 {
44262 #if wxUSE_UNICODE
44263 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44264 #else
44265 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44266 #endif
44267 }
44268 return resultobj;
44269 fail:
44270 return NULL;
44271 }
44272
44273
44274 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44275 PyObject *resultobj = 0;
44276 wxMenu *arg1 = (wxMenu *) 0 ;
44277 wxString *arg2 = 0 ;
44278 void *argp1 = 0 ;
44279 int res1 = 0 ;
44280 bool temp2 = false ;
44281 PyObject * obj0 = 0 ;
44282 PyObject * obj1 = 0 ;
44283 char * kwnames[] = {
44284 (char *) "self",(char *) "title", NULL
44285 };
44286
44287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
44288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44289 if (!SWIG_IsOK(res1)) {
44290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
44291 }
44292 arg1 = reinterpret_cast< wxMenu * >(argp1);
44293 {
44294 arg2 = wxString_in_helper(obj1);
44295 if (arg2 == NULL) SWIG_fail;
44296 temp2 = true;
44297 }
44298 {
44299 PyThreadState* __tstate = wxPyBeginAllowThreads();
44300 (arg1)->SetTitle((wxString const &)*arg2);
44301 wxPyEndAllowThreads(__tstate);
44302 if (PyErr_Occurred()) SWIG_fail;
44303 }
44304 resultobj = SWIG_Py_Void();
44305 {
44306 if (temp2)
44307 delete arg2;
44308 }
44309 return resultobj;
44310 fail:
44311 {
44312 if (temp2)
44313 delete arg2;
44314 }
44315 return NULL;
44316 }
44317
44318
44319 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44320 PyObject *resultobj = 0;
44321 wxMenu *arg1 = (wxMenu *) 0 ;
44322 wxString result;
44323 void *argp1 = 0 ;
44324 int res1 = 0 ;
44325 PyObject *swig_obj[1] ;
44326
44327 if (!args) SWIG_fail;
44328 swig_obj[0] = args;
44329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44330 if (!SWIG_IsOK(res1)) {
44331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44332 }
44333 arg1 = reinterpret_cast< wxMenu * >(argp1);
44334 {
44335 PyThreadState* __tstate = wxPyBeginAllowThreads();
44336 result = ((wxMenu const *)arg1)->GetTitle();
44337 wxPyEndAllowThreads(__tstate);
44338 if (PyErr_Occurred()) SWIG_fail;
44339 }
44340 {
44341 #if wxUSE_UNICODE
44342 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44343 #else
44344 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44345 #endif
44346 }
44347 return resultobj;
44348 fail:
44349 return NULL;
44350 }
44351
44352
44353 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44354 PyObject *resultobj = 0;
44355 wxMenu *arg1 = (wxMenu *) 0 ;
44356 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
44357 void *argp1 = 0 ;
44358 int res1 = 0 ;
44359 void *argp2 = 0 ;
44360 int res2 = 0 ;
44361 PyObject * obj0 = 0 ;
44362 PyObject * obj1 = 0 ;
44363 char * kwnames[] = {
44364 (char *) "self",(char *) "handler", NULL
44365 };
44366
44367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
44368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44369 if (!SWIG_IsOK(res1)) {
44370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44371 }
44372 arg1 = reinterpret_cast< wxMenu * >(argp1);
44373 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44374 if (!SWIG_IsOK(res2)) {
44375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44376 }
44377 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44378 {
44379 PyThreadState* __tstate = wxPyBeginAllowThreads();
44380 (arg1)->SetEventHandler(arg2);
44381 wxPyEndAllowThreads(__tstate);
44382 if (PyErr_Occurred()) SWIG_fail;
44383 }
44384 resultobj = SWIG_Py_Void();
44385 return resultobj;
44386 fail:
44387 return NULL;
44388 }
44389
44390
44391 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44392 PyObject *resultobj = 0;
44393 wxMenu *arg1 = (wxMenu *) 0 ;
44394 wxEvtHandler *result = 0 ;
44395 void *argp1 = 0 ;
44396 int res1 = 0 ;
44397 PyObject *swig_obj[1] ;
44398
44399 if (!args) SWIG_fail;
44400 swig_obj[0] = args;
44401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44402 if (!SWIG_IsOK(res1)) {
44403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44404 }
44405 arg1 = reinterpret_cast< wxMenu * >(argp1);
44406 {
44407 PyThreadState* __tstate = wxPyBeginAllowThreads();
44408 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44409 wxPyEndAllowThreads(__tstate);
44410 if (PyErr_Occurred()) SWIG_fail;
44411 }
44412 {
44413 resultobj = wxPyMake_wxObject(result, 0);
44414 }
44415 return resultobj;
44416 fail:
44417 return NULL;
44418 }
44419
44420
44421 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44422 PyObject *resultobj = 0;
44423 wxMenu *arg1 = (wxMenu *) 0 ;
44424 wxWindow *arg2 = (wxWindow *) 0 ;
44425 void *argp1 = 0 ;
44426 int res1 = 0 ;
44427 void *argp2 = 0 ;
44428 int res2 = 0 ;
44429 PyObject * obj0 = 0 ;
44430 PyObject * obj1 = 0 ;
44431 char * kwnames[] = {
44432 (char *) "self",(char *) "win", NULL
44433 };
44434
44435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44437 if (!SWIG_IsOK(res1)) {
44438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44439 }
44440 arg1 = reinterpret_cast< wxMenu * >(argp1);
44441 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44442 if (!SWIG_IsOK(res2)) {
44443 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44444 }
44445 arg2 = reinterpret_cast< wxWindow * >(argp2);
44446 {
44447 PyThreadState* __tstate = wxPyBeginAllowThreads();
44448 (arg1)->SetInvokingWindow(arg2);
44449 wxPyEndAllowThreads(__tstate);
44450 if (PyErr_Occurred()) SWIG_fail;
44451 }
44452 resultobj = SWIG_Py_Void();
44453 return resultobj;
44454 fail:
44455 return NULL;
44456 }
44457
44458
44459 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44460 PyObject *resultobj = 0;
44461 wxMenu *arg1 = (wxMenu *) 0 ;
44462 wxWindow *result = 0 ;
44463 void *argp1 = 0 ;
44464 int res1 = 0 ;
44465 PyObject *swig_obj[1] ;
44466
44467 if (!args) SWIG_fail;
44468 swig_obj[0] = args;
44469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44470 if (!SWIG_IsOK(res1)) {
44471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44472 }
44473 arg1 = reinterpret_cast< wxMenu * >(argp1);
44474 {
44475 PyThreadState* __tstate = wxPyBeginAllowThreads();
44476 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44477 wxPyEndAllowThreads(__tstate);
44478 if (PyErr_Occurred()) SWIG_fail;
44479 }
44480 {
44481 resultobj = wxPyMake_wxObject(result, 0);
44482 }
44483 return resultobj;
44484 fail:
44485 return NULL;
44486 }
44487
44488
44489 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44490 PyObject *resultobj = 0;
44491 wxMenu *arg1 = (wxMenu *) 0 ;
44492 long result;
44493 void *argp1 = 0 ;
44494 int res1 = 0 ;
44495 PyObject *swig_obj[1] ;
44496
44497 if (!args) SWIG_fail;
44498 swig_obj[0] = args;
44499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44500 if (!SWIG_IsOK(res1)) {
44501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44502 }
44503 arg1 = reinterpret_cast< wxMenu * >(argp1);
44504 {
44505 PyThreadState* __tstate = wxPyBeginAllowThreads();
44506 result = (long)((wxMenu const *)arg1)->GetStyle();
44507 wxPyEndAllowThreads(__tstate);
44508 if (PyErr_Occurred()) SWIG_fail;
44509 }
44510 resultobj = SWIG_From_long(static_cast< long >(result));
44511 return resultobj;
44512 fail:
44513 return NULL;
44514 }
44515
44516
44517 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44518 PyObject *resultobj = 0;
44519 wxMenu *arg1 = (wxMenu *) 0 ;
44520 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44521 void *argp1 = 0 ;
44522 int res1 = 0 ;
44523 void *argp2 = 0 ;
44524 int res2 = 0 ;
44525 PyObject * obj0 = 0 ;
44526 PyObject * obj1 = 0 ;
44527 char * kwnames[] = {
44528 (char *) "self",(char *) "source", NULL
44529 };
44530
44531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44533 if (!SWIG_IsOK(res1)) {
44534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44535 }
44536 arg1 = reinterpret_cast< wxMenu * >(argp1);
44537 if (obj1) {
44538 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44539 if (!SWIG_IsOK(res2)) {
44540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44541 }
44542 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44543 }
44544 {
44545 PyThreadState* __tstate = wxPyBeginAllowThreads();
44546 (arg1)->UpdateUI(arg2);
44547 wxPyEndAllowThreads(__tstate);
44548 if (PyErr_Occurred()) SWIG_fail;
44549 }
44550 resultobj = SWIG_Py_Void();
44551 return resultobj;
44552 fail:
44553 return NULL;
44554 }
44555
44556
44557 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44558 PyObject *resultobj = 0;
44559 wxMenu *arg1 = (wxMenu *) 0 ;
44560 wxMenuBar *result = 0 ;
44561 void *argp1 = 0 ;
44562 int res1 = 0 ;
44563 PyObject *swig_obj[1] ;
44564
44565 if (!args) SWIG_fail;
44566 swig_obj[0] = args;
44567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44568 if (!SWIG_IsOK(res1)) {
44569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44570 }
44571 arg1 = reinterpret_cast< wxMenu * >(argp1);
44572 {
44573 PyThreadState* __tstate = wxPyBeginAllowThreads();
44574 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44575 wxPyEndAllowThreads(__tstate);
44576 if (PyErr_Occurred()) SWIG_fail;
44577 }
44578 {
44579 resultobj = wxPyMake_wxObject(result, (bool)0);
44580 }
44581 return resultobj;
44582 fail:
44583 return NULL;
44584 }
44585
44586
44587 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44588 PyObject *resultobj = 0;
44589 wxMenu *arg1 = (wxMenu *) 0 ;
44590 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44591 void *argp1 = 0 ;
44592 int res1 = 0 ;
44593 void *argp2 = 0 ;
44594 int res2 = 0 ;
44595 PyObject * obj0 = 0 ;
44596 PyObject * obj1 = 0 ;
44597 char * kwnames[] = {
44598 (char *) "self",(char *) "menubar", NULL
44599 };
44600
44601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44603 if (!SWIG_IsOK(res1)) {
44604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44605 }
44606 arg1 = reinterpret_cast< wxMenu * >(argp1);
44607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44608 if (!SWIG_IsOK(res2)) {
44609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44610 }
44611 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44612 {
44613 PyThreadState* __tstate = wxPyBeginAllowThreads();
44614 (arg1)->Attach(arg2);
44615 wxPyEndAllowThreads(__tstate);
44616 if (PyErr_Occurred()) SWIG_fail;
44617 }
44618 resultobj = SWIG_Py_Void();
44619 return resultobj;
44620 fail:
44621 return NULL;
44622 }
44623
44624
44625 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44626 PyObject *resultobj = 0;
44627 wxMenu *arg1 = (wxMenu *) 0 ;
44628 void *argp1 = 0 ;
44629 int res1 = 0 ;
44630 PyObject *swig_obj[1] ;
44631
44632 if (!args) SWIG_fail;
44633 swig_obj[0] = args;
44634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44635 if (!SWIG_IsOK(res1)) {
44636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44637 }
44638 arg1 = reinterpret_cast< wxMenu * >(argp1);
44639 {
44640 PyThreadState* __tstate = wxPyBeginAllowThreads();
44641 (arg1)->Detach();
44642 wxPyEndAllowThreads(__tstate);
44643 if (PyErr_Occurred()) SWIG_fail;
44644 }
44645 resultobj = SWIG_Py_Void();
44646 return resultobj;
44647 fail:
44648 return NULL;
44649 }
44650
44651
44652 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44653 PyObject *resultobj = 0;
44654 wxMenu *arg1 = (wxMenu *) 0 ;
44655 bool result;
44656 void *argp1 = 0 ;
44657 int res1 = 0 ;
44658 PyObject *swig_obj[1] ;
44659
44660 if (!args) SWIG_fail;
44661 swig_obj[0] = args;
44662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44663 if (!SWIG_IsOK(res1)) {
44664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44665 }
44666 arg1 = reinterpret_cast< wxMenu * >(argp1);
44667 {
44668 PyThreadState* __tstate = wxPyBeginAllowThreads();
44669 result = (bool)((wxMenu const *)arg1)->IsAttached();
44670 wxPyEndAllowThreads(__tstate);
44671 if (PyErr_Occurred()) SWIG_fail;
44672 }
44673 {
44674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44675 }
44676 return resultobj;
44677 fail:
44678 return NULL;
44679 }
44680
44681
44682 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44683 PyObject *resultobj = 0;
44684 wxMenu *arg1 = (wxMenu *) 0 ;
44685 wxMenu *arg2 = (wxMenu *) 0 ;
44686 void *argp1 = 0 ;
44687 int res1 = 0 ;
44688 void *argp2 = 0 ;
44689 int res2 = 0 ;
44690 PyObject * obj0 = 0 ;
44691 PyObject * obj1 = 0 ;
44692 char * kwnames[] = {
44693 (char *) "self",(char *) "parent", NULL
44694 };
44695
44696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44698 if (!SWIG_IsOK(res1)) {
44699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44700 }
44701 arg1 = reinterpret_cast< wxMenu * >(argp1);
44702 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44703 if (!SWIG_IsOK(res2)) {
44704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44705 }
44706 arg2 = reinterpret_cast< wxMenu * >(argp2);
44707 {
44708 PyThreadState* __tstate = wxPyBeginAllowThreads();
44709 (arg1)->SetParent(arg2);
44710 wxPyEndAllowThreads(__tstate);
44711 if (PyErr_Occurred()) SWIG_fail;
44712 }
44713 resultobj = SWIG_Py_Void();
44714 return resultobj;
44715 fail:
44716 return NULL;
44717 }
44718
44719
44720 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44721 PyObject *resultobj = 0;
44722 wxMenu *arg1 = (wxMenu *) 0 ;
44723 wxMenu *result = 0 ;
44724 void *argp1 = 0 ;
44725 int res1 = 0 ;
44726 PyObject *swig_obj[1] ;
44727
44728 if (!args) SWIG_fail;
44729 swig_obj[0] = args;
44730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44731 if (!SWIG_IsOK(res1)) {
44732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44733 }
44734 arg1 = reinterpret_cast< wxMenu * >(argp1);
44735 {
44736 PyThreadState* __tstate = wxPyBeginAllowThreads();
44737 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44738 wxPyEndAllowThreads(__tstate);
44739 if (PyErr_Occurred()) SWIG_fail;
44740 }
44741 {
44742 resultobj = wxPyMake_wxObject(result, 0);
44743 }
44744 return resultobj;
44745 fail:
44746 return NULL;
44747 }
44748
44749
44750 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44751 PyObject *obj;
44752 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44753 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44754 return SWIG_Py_Void();
44755 }
44756
44757 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44758 return SWIG_Python_InitShadowInstance(args);
44759 }
44760
44761 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44762 PyObject *resultobj = 0;
44763 long arg1 = (long) 0 ;
44764 wxMenuBar *result = 0 ;
44765 long val1 ;
44766 int ecode1 = 0 ;
44767 PyObject * obj0 = 0 ;
44768 char * kwnames[] = {
44769 (char *) "style", NULL
44770 };
44771
44772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44773 if (obj0) {
44774 ecode1 = SWIG_AsVal_long(obj0, &val1);
44775 if (!SWIG_IsOK(ecode1)) {
44776 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44777 }
44778 arg1 = static_cast< long >(val1);
44779 }
44780 {
44781 if (!wxPyCheckForApp()) SWIG_fail;
44782 PyThreadState* __tstate = wxPyBeginAllowThreads();
44783 result = (wxMenuBar *)new wxMenuBar(arg1);
44784 wxPyEndAllowThreads(__tstate);
44785 if (PyErr_Occurred()) SWIG_fail;
44786 }
44787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44788 return resultobj;
44789 fail:
44790 return NULL;
44791 }
44792
44793
44794 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44795 PyObject *resultobj = 0;
44796 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44797 wxMenu *arg2 = (wxMenu *) 0 ;
44798 wxString *arg3 = 0 ;
44799 bool result;
44800 void *argp1 = 0 ;
44801 int res1 = 0 ;
44802 void *argp2 = 0 ;
44803 int res2 = 0 ;
44804 bool temp3 = false ;
44805 PyObject * obj0 = 0 ;
44806 PyObject * obj1 = 0 ;
44807 PyObject * obj2 = 0 ;
44808 char * kwnames[] = {
44809 (char *) "self",(char *) "menu",(char *) "title", NULL
44810 };
44811
44812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) 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_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44816 }
44817 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44818 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44819 if (!SWIG_IsOK(res2)) {
44820 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44821 }
44822 arg2 = reinterpret_cast< wxMenu * >(argp2);
44823 {
44824 arg3 = wxString_in_helper(obj2);
44825 if (arg3 == NULL) SWIG_fail;
44826 temp3 = true;
44827 }
44828 {
44829 PyThreadState* __tstate = wxPyBeginAllowThreads();
44830 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44831 wxPyEndAllowThreads(__tstate);
44832 if (PyErr_Occurred()) SWIG_fail;
44833 }
44834 {
44835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44836 }
44837 {
44838 if (temp3)
44839 delete arg3;
44840 }
44841 return resultobj;
44842 fail:
44843 {
44844 if (temp3)
44845 delete arg3;
44846 }
44847 return NULL;
44848 }
44849
44850
44851 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44852 PyObject *resultobj = 0;
44853 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44854 size_t arg2 ;
44855 wxMenu *arg3 = (wxMenu *) 0 ;
44856 wxString *arg4 = 0 ;
44857 bool result;
44858 void *argp1 = 0 ;
44859 int res1 = 0 ;
44860 size_t val2 ;
44861 int ecode2 = 0 ;
44862 void *argp3 = 0 ;
44863 int res3 = 0 ;
44864 bool temp4 = false ;
44865 PyObject * obj0 = 0 ;
44866 PyObject * obj1 = 0 ;
44867 PyObject * obj2 = 0 ;
44868 PyObject * obj3 = 0 ;
44869 char * kwnames[] = {
44870 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44871 };
44872
44873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44875 if (!SWIG_IsOK(res1)) {
44876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44877 }
44878 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44879 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44880 if (!SWIG_IsOK(ecode2)) {
44881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44882 }
44883 arg2 = static_cast< size_t >(val2);
44884 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44885 if (!SWIG_IsOK(res3)) {
44886 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44887 }
44888 arg3 = reinterpret_cast< wxMenu * >(argp3);
44889 {
44890 arg4 = wxString_in_helper(obj3);
44891 if (arg4 == NULL) SWIG_fail;
44892 temp4 = true;
44893 }
44894 {
44895 PyThreadState* __tstate = wxPyBeginAllowThreads();
44896 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44897 wxPyEndAllowThreads(__tstate);
44898 if (PyErr_Occurred()) SWIG_fail;
44899 }
44900 {
44901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44902 }
44903 {
44904 if (temp4)
44905 delete arg4;
44906 }
44907 return resultobj;
44908 fail:
44909 {
44910 if (temp4)
44911 delete arg4;
44912 }
44913 return NULL;
44914 }
44915
44916
44917 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44918 PyObject *resultobj = 0;
44919 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44920 size_t result;
44921 void *argp1 = 0 ;
44922 int res1 = 0 ;
44923 PyObject *swig_obj[1] ;
44924
44925 if (!args) SWIG_fail;
44926 swig_obj[0] = args;
44927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44928 if (!SWIG_IsOK(res1)) {
44929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44930 }
44931 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44932 {
44933 PyThreadState* __tstate = wxPyBeginAllowThreads();
44934 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44935 wxPyEndAllowThreads(__tstate);
44936 if (PyErr_Occurred()) SWIG_fail;
44937 }
44938 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44939 return resultobj;
44940 fail:
44941 return NULL;
44942 }
44943
44944
44945 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44946 PyObject *resultobj = 0;
44947 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44948 size_t arg2 ;
44949 wxMenu *result = 0 ;
44950 void *argp1 = 0 ;
44951 int res1 = 0 ;
44952 size_t val2 ;
44953 int ecode2 = 0 ;
44954 PyObject * obj0 = 0 ;
44955 PyObject * obj1 = 0 ;
44956 char * kwnames[] = {
44957 (char *) "self",(char *) "pos", NULL
44958 };
44959
44960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44962 if (!SWIG_IsOK(res1)) {
44963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44964 }
44965 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44966 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44967 if (!SWIG_IsOK(ecode2)) {
44968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44969 }
44970 arg2 = static_cast< size_t >(val2);
44971 {
44972 PyThreadState* __tstate = wxPyBeginAllowThreads();
44973 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44974 wxPyEndAllowThreads(__tstate);
44975 if (PyErr_Occurred()) SWIG_fail;
44976 }
44977 {
44978 resultobj = wxPyMake_wxObject(result, 0);
44979 }
44980 return resultobj;
44981 fail:
44982 return NULL;
44983 }
44984
44985
44986 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44987 PyObject *resultobj = 0;
44988 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44989 size_t arg2 ;
44990 wxMenu *arg3 = (wxMenu *) 0 ;
44991 wxString *arg4 = 0 ;
44992 wxMenu *result = 0 ;
44993 void *argp1 = 0 ;
44994 int res1 = 0 ;
44995 size_t val2 ;
44996 int ecode2 = 0 ;
44997 void *argp3 = 0 ;
44998 int res3 = 0 ;
44999 bool temp4 = false ;
45000 PyObject * obj0 = 0 ;
45001 PyObject * obj1 = 0 ;
45002 PyObject * obj2 = 0 ;
45003 PyObject * obj3 = 0 ;
45004 char * kwnames[] = {
45005 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
45006 };
45007
45008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45010 if (!SWIG_IsOK(res1)) {
45011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45012 }
45013 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45014 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45015 if (!SWIG_IsOK(ecode2)) {
45016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
45017 }
45018 arg2 = static_cast< size_t >(val2);
45019 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
45020 if (!SWIG_IsOK(res3)) {
45021 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
45022 }
45023 arg3 = reinterpret_cast< wxMenu * >(argp3);
45024 {
45025 arg4 = wxString_in_helper(obj3);
45026 if (arg4 == NULL) SWIG_fail;
45027 temp4 = true;
45028 }
45029 {
45030 PyThreadState* __tstate = wxPyBeginAllowThreads();
45031 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
45032 wxPyEndAllowThreads(__tstate);
45033 if (PyErr_Occurred()) SWIG_fail;
45034 }
45035 {
45036 resultobj = wxPyMake_wxObject(result, 0);
45037 }
45038 {
45039 if (temp4)
45040 delete arg4;
45041 }
45042 return resultobj;
45043 fail:
45044 {
45045 if (temp4)
45046 delete arg4;
45047 }
45048 return NULL;
45049 }
45050
45051
45052 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45053 PyObject *resultobj = 0;
45054 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45055 size_t arg2 ;
45056 wxMenu *result = 0 ;
45057 void *argp1 = 0 ;
45058 int res1 = 0 ;
45059 size_t val2 ;
45060 int ecode2 = 0 ;
45061 PyObject * obj0 = 0 ;
45062 PyObject * obj1 = 0 ;
45063 char * kwnames[] = {
45064 (char *) "self",(char *) "pos", NULL
45065 };
45066
45067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
45068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45069 if (!SWIG_IsOK(res1)) {
45070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45071 }
45072 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45073 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45074 if (!SWIG_IsOK(ecode2)) {
45075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
45076 }
45077 arg2 = static_cast< size_t >(val2);
45078 {
45079 PyThreadState* __tstate = wxPyBeginAllowThreads();
45080 result = (wxMenu *)(arg1)->Remove(arg2);
45081 wxPyEndAllowThreads(__tstate);
45082 if (PyErr_Occurred()) SWIG_fail;
45083 }
45084 {
45085 resultobj = wxPyMake_wxObject(result, 0);
45086 }
45087 return resultobj;
45088 fail:
45089 return NULL;
45090 }
45091
45092
45093 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45094 PyObject *resultobj = 0;
45095 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45096 size_t arg2 ;
45097 bool arg3 ;
45098 void *argp1 = 0 ;
45099 int res1 = 0 ;
45100 size_t val2 ;
45101 int ecode2 = 0 ;
45102 bool val3 ;
45103 int ecode3 = 0 ;
45104 PyObject * obj0 = 0 ;
45105 PyObject * obj1 = 0 ;
45106 PyObject * obj2 = 0 ;
45107 char * kwnames[] = {
45108 (char *) "self",(char *) "pos",(char *) "enable", NULL
45109 };
45110
45111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45113 if (!SWIG_IsOK(res1)) {
45114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45115 }
45116 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45117 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45118 if (!SWIG_IsOK(ecode2)) {
45119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
45120 }
45121 arg2 = static_cast< size_t >(val2);
45122 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45123 if (!SWIG_IsOK(ecode3)) {
45124 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
45125 }
45126 arg3 = static_cast< bool >(val3);
45127 {
45128 PyThreadState* __tstate = wxPyBeginAllowThreads();
45129 (arg1)->EnableTop(arg2,arg3);
45130 wxPyEndAllowThreads(__tstate);
45131 if (PyErr_Occurred()) SWIG_fail;
45132 }
45133 resultobj = SWIG_Py_Void();
45134 return resultobj;
45135 fail:
45136 return NULL;
45137 }
45138
45139
45140 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45141 PyObject *resultobj = 0;
45142 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45143 size_t arg2 ;
45144 bool result;
45145 void *argp1 = 0 ;
45146 int res1 = 0 ;
45147 size_t val2 ;
45148 int ecode2 = 0 ;
45149 PyObject * obj0 = 0 ;
45150 PyObject * obj1 = 0 ;
45151 char * kwnames[] = {
45152 (char *) "self",(char *) "pos", NULL
45153 };
45154
45155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
45156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45157 if (!SWIG_IsOK(res1)) {
45158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45159 }
45160 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45161 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45162 if (!SWIG_IsOK(ecode2)) {
45163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
45164 }
45165 arg2 = static_cast< size_t >(val2);
45166 {
45167 PyThreadState* __tstate = wxPyBeginAllowThreads();
45168 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
45169 wxPyEndAllowThreads(__tstate);
45170 if (PyErr_Occurred()) SWIG_fail;
45171 }
45172 {
45173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45174 }
45175 return resultobj;
45176 fail:
45177 return NULL;
45178 }
45179
45180
45181 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45182 PyObject *resultobj = 0;
45183 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45184 size_t arg2 ;
45185 wxString *arg3 = 0 ;
45186 void *argp1 = 0 ;
45187 int res1 = 0 ;
45188 size_t val2 ;
45189 int ecode2 = 0 ;
45190 bool temp3 = false ;
45191 PyObject * obj0 = 0 ;
45192 PyObject * obj1 = 0 ;
45193 PyObject * obj2 = 0 ;
45194 char * kwnames[] = {
45195 (char *) "self",(char *) "pos",(char *) "label", NULL
45196 };
45197
45198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45200 if (!SWIG_IsOK(res1)) {
45201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45202 }
45203 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45204 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45205 if (!SWIG_IsOK(ecode2)) {
45206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45207 }
45208 arg2 = static_cast< size_t >(val2);
45209 {
45210 arg3 = wxString_in_helper(obj2);
45211 if (arg3 == NULL) SWIG_fail;
45212 temp3 = true;
45213 }
45214 {
45215 PyThreadState* __tstate = wxPyBeginAllowThreads();
45216 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
45217 wxPyEndAllowThreads(__tstate);
45218 if (PyErr_Occurred()) SWIG_fail;
45219 }
45220 resultobj = SWIG_Py_Void();
45221 {
45222 if (temp3)
45223 delete arg3;
45224 }
45225 return resultobj;
45226 fail:
45227 {
45228 if (temp3)
45229 delete arg3;
45230 }
45231 return NULL;
45232 }
45233
45234
45235 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45236 PyObject *resultobj = 0;
45237 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45238 size_t arg2 ;
45239 wxString result;
45240 void *argp1 = 0 ;
45241 int res1 = 0 ;
45242 size_t val2 ;
45243 int ecode2 = 0 ;
45244 PyObject * obj0 = 0 ;
45245 PyObject * obj1 = 0 ;
45246 char * kwnames[] = {
45247 (char *) "self",(char *) "pos", NULL
45248 };
45249
45250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
45251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45252 if (!SWIG_IsOK(res1)) {
45253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45254 }
45255 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45256 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45257 if (!SWIG_IsOK(ecode2)) {
45258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45259 }
45260 arg2 = static_cast< size_t >(val2);
45261 {
45262 PyThreadState* __tstate = wxPyBeginAllowThreads();
45263 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
45264 wxPyEndAllowThreads(__tstate);
45265 if (PyErr_Occurred()) SWIG_fail;
45266 }
45267 {
45268 #if wxUSE_UNICODE
45269 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45270 #else
45271 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45272 #endif
45273 }
45274 return resultobj;
45275 fail:
45276 return NULL;
45277 }
45278
45279
45280 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45281 PyObject *resultobj = 0;
45282 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45283 wxString *arg2 = 0 ;
45284 wxString *arg3 = 0 ;
45285 int result;
45286 void *argp1 = 0 ;
45287 int res1 = 0 ;
45288 bool temp2 = false ;
45289 bool temp3 = false ;
45290 PyObject * obj0 = 0 ;
45291 PyObject * obj1 = 0 ;
45292 PyObject * obj2 = 0 ;
45293 char * kwnames[] = {
45294 (char *) "self",(char *) "menu",(char *) "item", NULL
45295 };
45296
45297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45299 if (!SWIG_IsOK(res1)) {
45300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45301 }
45302 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45303 {
45304 arg2 = wxString_in_helper(obj1);
45305 if (arg2 == NULL) SWIG_fail;
45306 temp2 = true;
45307 }
45308 {
45309 arg3 = wxString_in_helper(obj2);
45310 if (arg3 == NULL) SWIG_fail;
45311 temp3 = true;
45312 }
45313 {
45314 PyThreadState* __tstate = wxPyBeginAllowThreads();
45315 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
45316 wxPyEndAllowThreads(__tstate);
45317 if (PyErr_Occurred()) SWIG_fail;
45318 }
45319 resultobj = SWIG_From_int(static_cast< int >(result));
45320 {
45321 if (temp2)
45322 delete arg2;
45323 }
45324 {
45325 if (temp3)
45326 delete arg3;
45327 }
45328 return resultobj;
45329 fail:
45330 {
45331 if (temp2)
45332 delete arg2;
45333 }
45334 {
45335 if (temp3)
45336 delete arg3;
45337 }
45338 return NULL;
45339 }
45340
45341
45342 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45343 PyObject *resultobj = 0;
45344 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45345 int arg2 ;
45346 wxMenuItem *result = 0 ;
45347 void *argp1 = 0 ;
45348 int res1 = 0 ;
45349 int val2 ;
45350 int ecode2 = 0 ;
45351 PyObject * obj0 = 0 ;
45352 PyObject * obj1 = 0 ;
45353 char * kwnames[] = {
45354 (char *) "self",(char *) "id", NULL
45355 };
45356
45357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
45358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45359 if (!SWIG_IsOK(res1)) {
45360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45361 }
45362 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45363 ecode2 = SWIG_AsVal_int(obj1, &val2);
45364 if (!SWIG_IsOK(ecode2)) {
45365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
45366 }
45367 arg2 = static_cast< int >(val2);
45368 {
45369 PyThreadState* __tstate = wxPyBeginAllowThreads();
45370 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45371 wxPyEndAllowThreads(__tstate);
45372 if (PyErr_Occurred()) SWIG_fail;
45373 }
45374 {
45375 resultobj = wxPyMake_wxObject(result, (bool)0);
45376 }
45377 return resultobj;
45378 fail:
45379 return NULL;
45380 }
45381
45382
45383 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45384 PyObject *resultobj = 0;
45385 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45386 wxString *arg2 = 0 ;
45387 int result;
45388 void *argp1 = 0 ;
45389 int res1 = 0 ;
45390 bool temp2 = false ;
45391 PyObject * obj0 = 0 ;
45392 PyObject * obj1 = 0 ;
45393 char * kwnames[] = {
45394 (char *) "self",(char *) "title", NULL
45395 };
45396
45397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45399 if (!SWIG_IsOK(res1)) {
45400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45401 }
45402 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45403 {
45404 arg2 = wxString_in_helper(obj1);
45405 if (arg2 == NULL) SWIG_fail;
45406 temp2 = true;
45407 }
45408 {
45409 PyThreadState* __tstate = wxPyBeginAllowThreads();
45410 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45411 wxPyEndAllowThreads(__tstate);
45412 if (PyErr_Occurred()) SWIG_fail;
45413 }
45414 resultobj = SWIG_From_int(static_cast< int >(result));
45415 {
45416 if (temp2)
45417 delete arg2;
45418 }
45419 return resultobj;
45420 fail:
45421 {
45422 if (temp2)
45423 delete arg2;
45424 }
45425 return NULL;
45426 }
45427
45428
45429 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45430 PyObject *resultobj = 0;
45431 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45432 int arg2 ;
45433 bool arg3 ;
45434 void *argp1 = 0 ;
45435 int res1 = 0 ;
45436 int val2 ;
45437 int ecode2 = 0 ;
45438 bool val3 ;
45439 int ecode3 = 0 ;
45440 PyObject * obj0 = 0 ;
45441 PyObject * obj1 = 0 ;
45442 PyObject * obj2 = 0 ;
45443 char * kwnames[] = {
45444 (char *) "self",(char *) "id",(char *) "enable", NULL
45445 };
45446
45447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45449 if (!SWIG_IsOK(res1)) {
45450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45451 }
45452 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45453 ecode2 = SWIG_AsVal_int(obj1, &val2);
45454 if (!SWIG_IsOK(ecode2)) {
45455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45456 }
45457 arg2 = static_cast< int >(val2);
45458 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45459 if (!SWIG_IsOK(ecode3)) {
45460 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45461 }
45462 arg3 = static_cast< bool >(val3);
45463 {
45464 PyThreadState* __tstate = wxPyBeginAllowThreads();
45465 (arg1)->Enable(arg2,arg3);
45466 wxPyEndAllowThreads(__tstate);
45467 if (PyErr_Occurred()) SWIG_fail;
45468 }
45469 resultobj = SWIG_Py_Void();
45470 return resultobj;
45471 fail:
45472 return NULL;
45473 }
45474
45475
45476 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45477 PyObject *resultobj = 0;
45478 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45479 int arg2 ;
45480 bool arg3 ;
45481 void *argp1 = 0 ;
45482 int res1 = 0 ;
45483 int val2 ;
45484 int ecode2 = 0 ;
45485 bool val3 ;
45486 int ecode3 = 0 ;
45487 PyObject * obj0 = 0 ;
45488 PyObject * obj1 = 0 ;
45489 PyObject * obj2 = 0 ;
45490 char * kwnames[] = {
45491 (char *) "self",(char *) "id",(char *) "check", NULL
45492 };
45493
45494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45496 if (!SWIG_IsOK(res1)) {
45497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45498 }
45499 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45500 ecode2 = SWIG_AsVal_int(obj1, &val2);
45501 if (!SWIG_IsOK(ecode2)) {
45502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45503 }
45504 arg2 = static_cast< int >(val2);
45505 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45506 if (!SWIG_IsOK(ecode3)) {
45507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45508 }
45509 arg3 = static_cast< bool >(val3);
45510 {
45511 PyThreadState* __tstate = wxPyBeginAllowThreads();
45512 (arg1)->Check(arg2,arg3);
45513 wxPyEndAllowThreads(__tstate);
45514 if (PyErr_Occurred()) SWIG_fail;
45515 }
45516 resultobj = SWIG_Py_Void();
45517 return resultobj;
45518 fail:
45519 return NULL;
45520 }
45521
45522
45523 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45524 PyObject *resultobj = 0;
45525 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45526 int arg2 ;
45527 bool result;
45528 void *argp1 = 0 ;
45529 int res1 = 0 ;
45530 int val2 ;
45531 int ecode2 = 0 ;
45532 PyObject * obj0 = 0 ;
45533 PyObject * obj1 = 0 ;
45534 char * kwnames[] = {
45535 (char *) "self",(char *) "id", NULL
45536 };
45537
45538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45540 if (!SWIG_IsOK(res1)) {
45541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45542 }
45543 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45544 ecode2 = SWIG_AsVal_int(obj1, &val2);
45545 if (!SWIG_IsOK(ecode2)) {
45546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45547 }
45548 arg2 = static_cast< int >(val2);
45549 {
45550 PyThreadState* __tstate = wxPyBeginAllowThreads();
45551 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45552 wxPyEndAllowThreads(__tstate);
45553 if (PyErr_Occurred()) SWIG_fail;
45554 }
45555 {
45556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45557 }
45558 return resultobj;
45559 fail:
45560 return NULL;
45561 }
45562
45563
45564 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45565 PyObject *resultobj = 0;
45566 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45567 int arg2 ;
45568 bool result;
45569 void *argp1 = 0 ;
45570 int res1 = 0 ;
45571 int val2 ;
45572 int ecode2 = 0 ;
45573 PyObject * obj0 = 0 ;
45574 PyObject * obj1 = 0 ;
45575 char * kwnames[] = {
45576 (char *) "self",(char *) "id", NULL
45577 };
45578
45579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45581 if (!SWIG_IsOK(res1)) {
45582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45583 }
45584 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45585 ecode2 = SWIG_AsVal_int(obj1, &val2);
45586 if (!SWIG_IsOK(ecode2)) {
45587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45588 }
45589 arg2 = static_cast< int >(val2);
45590 {
45591 PyThreadState* __tstate = wxPyBeginAllowThreads();
45592 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45593 wxPyEndAllowThreads(__tstate);
45594 if (PyErr_Occurred()) SWIG_fail;
45595 }
45596 {
45597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45598 }
45599 return resultobj;
45600 fail:
45601 return NULL;
45602 }
45603
45604
45605 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45606 PyObject *resultobj = 0;
45607 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45608 int arg2 ;
45609 wxString *arg3 = 0 ;
45610 void *argp1 = 0 ;
45611 int res1 = 0 ;
45612 int val2 ;
45613 int ecode2 = 0 ;
45614 bool temp3 = false ;
45615 PyObject * obj0 = 0 ;
45616 PyObject * obj1 = 0 ;
45617 PyObject * obj2 = 0 ;
45618 char * kwnames[] = {
45619 (char *) "self",(char *) "id",(char *) "label", NULL
45620 };
45621
45622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45624 if (!SWIG_IsOK(res1)) {
45625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45626 }
45627 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45628 ecode2 = SWIG_AsVal_int(obj1, &val2);
45629 if (!SWIG_IsOK(ecode2)) {
45630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45631 }
45632 arg2 = static_cast< int >(val2);
45633 {
45634 arg3 = wxString_in_helper(obj2);
45635 if (arg3 == NULL) SWIG_fail;
45636 temp3 = true;
45637 }
45638 {
45639 PyThreadState* __tstate = wxPyBeginAllowThreads();
45640 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45641 wxPyEndAllowThreads(__tstate);
45642 if (PyErr_Occurred()) SWIG_fail;
45643 }
45644 resultobj = SWIG_Py_Void();
45645 {
45646 if (temp3)
45647 delete arg3;
45648 }
45649 return resultobj;
45650 fail:
45651 {
45652 if (temp3)
45653 delete arg3;
45654 }
45655 return NULL;
45656 }
45657
45658
45659 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45660 PyObject *resultobj = 0;
45661 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45662 int arg2 ;
45663 wxString result;
45664 void *argp1 = 0 ;
45665 int res1 = 0 ;
45666 int val2 ;
45667 int ecode2 = 0 ;
45668 PyObject * obj0 = 0 ;
45669 PyObject * obj1 = 0 ;
45670 char * kwnames[] = {
45671 (char *) "self",(char *) "id", NULL
45672 };
45673
45674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45676 if (!SWIG_IsOK(res1)) {
45677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45678 }
45679 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45680 ecode2 = SWIG_AsVal_int(obj1, &val2);
45681 if (!SWIG_IsOK(ecode2)) {
45682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45683 }
45684 arg2 = static_cast< int >(val2);
45685 {
45686 PyThreadState* __tstate = wxPyBeginAllowThreads();
45687 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45688 wxPyEndAllowThreads(__tstate);
45689 if (PyErr_Occurred()) SWIG_fail;
45690 }
45691 {
45692 #if wxUSE_UNICODE
45693 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45694 #else
45695 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45696 #endif
45697 }
45698 return resultobj;
45699 fail:
45700 return NULL;
45701 }
45702
45703
45704 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45705 PyObject *resultobj = 0;
45706 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45707 int arg2 ;
45708 wxString *arg3 = 0 ;
45709 void *argp1 = 0 ;
45710 int res1 = 0 ;
45711 int val2 ;
45712 int ecode2 = 0 ;
45713 bool temp3 = false ;
45714 PyObject * obj0 = 0 ;
45715 PyObject * obj1 = 0 ;
45716 PyObject * obj2 = 0 ;
45717 char * kwnames[] = {
45718 (char *) "self",(char *) "id",(char *) "helpString", NULL
45719 };
45720
45721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45723 if (!SWIG_IsOK(res1)) {
45724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45725 }
45726 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45727 ecode2 = SWIG_AsVal_int(obj1, &val2);
45728 if (!SWIG_IsOK(ecode2)) {
45729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45730 }
45731 arg2 = static_cast< int >(val2);
45732 {
45733 arg3 = wxString_in_helper(obj2);
45734 if (arg3 == NULL) SWIG_fail;
45735 temp3 = true;
45736 }
45737 {
45738 PyThreadState* __tstate = wxPyBeginAllowThreads();
45739 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45740 wxPyEndAllowThreads(__tstate);
45741 if (PyErr_Occurred()) SWIG_fail;
45742 }
45743 resultobj = SWIG_Py_Void();
45744 {
45745 if (temp3)
45746 delete arg3;
45747 }
45748 return resultobj;
45749 fail:
45750 {
45751 if (temp3)
45752 delete arg3;
45753 }
45754 return NULL;
45755 }
45756
45757
45758 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45759 PyObject *resultobj = 0;
45760 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45761 int arg2 ;
45762 wxString result;
45763 void *argp1 = 0 ;
45764 int res1 = 0 ;
45765 int val2 ;
45766 int ecode2 = 0 ;
45767 PyObject * obj0 = 0 ;
45768 PyObject * obj1 = 0 ;
45769 char * kwnames[] = {
45770 (char *) "self",(char *) "id", NULL
45771 };
45772
45773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45775 if (!SWIG_IsOK(res1)) {
45776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45777 }
45778 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45779 ecode2 = SWIG_AsVal_int(obj1, &val2);
45780 if (!SWIG_IsOK(ecode2)) {
45781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45782 }
45783 arg2 = static_cast< int >(val2);
45784 {
45785 PyThreadState* __tstate = wxPyBeginAllowThreads();
45786 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45787 wxPyEndAllowThreads(__tstate);
45788 if (PyErr_Occurred()) SWIG_fail;
45789 }
45790 {
45791 #if wxUSE_UNICODE
45792 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45793 #else
45794 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45795 #endif
45796 }
45797 return resultobj;
45798 fail:
45799 return NULL;
45800 }
45801
45802
45803 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45804 PyObject *resultobj = 0;
45805 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45806 wxFrame *result = 0 ;
45807 void *argp1 = 0 ;
45808 int res1 = 0 ;
45809 PyObject *swig_obj[1] ;
45810
45811 if (!args) SWIG_fail;
45812 swig_obj[0] = args;
45813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45814 if (!SWIG_IsOK(res1)) {
45815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45816 }
45817 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45818 {
45819 PyThreadState* __tstate = wxPyBeginAllowThreads();
45820 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45821 wxPyEndAllowThreads(__tstate);
45822 if (PyErr_Occurred()) SWIG_fail;
45823 }
45824 {
45825 resultobj = wxPyMake_wxObject(result, (bool)0);
45826 }
45827 return resultobj;
45828 fail:
45829 return NULL;
45830 }
45831
45832
45833 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45834 PyObject *resultobj = 0;
45835 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45836 bool result;
45837 void *argp1 = 0 ;
45838 int res1 = 0 ;
45839 PyObject *swig_obj[1] ;
45840
45841 if (!args) SWIG_fail;
45842 swig_obj[0] = args;
45843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45844 if (!SWIG_IsOK(res1)) {
45845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45846 }
45847 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45848 {
45849 PyThreadState* __tstate = wxPyBeginAllowThreads();
45850 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45851 wxPyEndAllowThreads(__tstate);
45852 if (PyErr_Occurred()) SWIG_fail;
45853 }
45854 {
45855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45856 }
45857 return resultobj;
45858 fail:
45859 return NULL;
45860 }
45861
45862
45863 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45864 PyObject *resultobj = 0;
45865 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45866 wxFrame *arg2 = (wxFrame *) 0 ;
45867 void *argp1 = 0 ;
45868 int res1 = 0 ;
45869 void *argp2 = 0 ;
45870 int res2 = 0 ;
45871 PyObject * obj0 = 0 ;
45872 PyObject * obj1 = 0 ;
45873 char * kwnames[] = {
45874 (char *) "self",(char *) "frame", NULL
45875 };
45876
45877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45879 if (!SWIG_IsOK(res1)) {
45880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45881 }
45882 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45883 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45884 if (!SWIG_IsOK(res2)) {
45885 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45886 }
45887 arg2 = reinterpret_cast< wxFrame * >(argp2);
45888 {
45889 PyThreadState* __tstate = wxPyBeginAllowThreads();
45890 (arg1)->Attach(arg2);
45891 wxPyEndAllowThreads(__tstate);
45892 if (PyErr_Occurred()) SWIG_fail;
45893 }
45894 resultobj = SWIG_Py_Void();
45895 return resultobj;
45896 fail:
45897 return NULL;
45898 }
45899
45900
45901 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45902 PyObject *resultobj = 0;
45903 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45904 void *argp1 = 0 ;
45905 int res1 = 0 ;
45906 PyObject *swig_obj[1] ;
45907
45908 if (!args) SWIG_fail;
45909 swig_obj[0] = args;
45910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45911 if (!SWIG_IsOK(res1)) {
45912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45913 }
45914 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45915 {
45916 PyThreadState* __tstate = wxPyBeginAllowThreads();
45917 (arg1)->Detach();
45918 wxPyEndAllowThreads(__tstate);
45919 if (PyErr_Occurred()) SWIG_fail;
45920 }
45921 resultobj = SWIG_Py_Void();
45922 return resultobj;
45923 fail:
45924 return NULL;
45925 }
45926
45927
45928 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45929 PyObject *resultobj = 0;
45930 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45931 void *argp1 = 0 ;
45932 int res1 = 0 ;
45933 PyObject *swig_obj[1] ;
45934
45935 if (!args) SWIG_fail;
45936 swig_obj[0] = args;
45937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45938 if (!SWIG_IsOK(res1)) {
45939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45940 }
45941 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45942 {
45943 PyThreadState* __tstate = wxPyBeginAllowThreads();
45944 (arg1)->UpdateMenus();
45945 wxPyEndAllowThreads(__tstate);
45946 if (PyErr_Occurred()) SWIG_fail;
45947 }
45948 resultobj = SWIG_Py_Void();
45949 return resultobj;
45950 fail:
45951 return NULL;
45952 }
45953
45954
45955 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45956 PyObject *resultobj = 0;
45957 bool arg1 ;
45958 bool val1 ;
45959 int ecode1 = 0 ;
45960 PyObject * obj0 = 0 ;
45961 char * kwnames[] = {
45962 (char *) "enable", NULL
45963 };
45964
45965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45966 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45967 if (!SWIG_IsOK(ecode1)) {
45968 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45969 }
45970 arg1 = static_cast< bool >(val1);
45971 {
45972 PyThreadState* __tstate = wxPyBeginAllowThreads();
45973 wxMenuBar_SetAutoWindowMenu(arg1);
45974 wxPyEndAllowThreads(__tstate);
45975 if (PyErr_Occurred()) SWIG_fail;
45976 }
45977 resultobj = SWIG_Py_Void();
45978 return resultobj;
45979 fail:
45980 return NULL;
45981 }
45982
45983
45984 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45985 PyObject *resultobj = 0;
45986 bool result;
45987
45988 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45989 {
45990 PyThreadState* __tstate = wxPyBeginAllowThreads();
45991 result = (bool)wxMenuBar_GetAutoWindowMenu();
45992 wxPyEndAllowThreads(__tstate);
45993 if (PyErr_Occurred()) SWIG_fail;
45994 }
45995 {
45996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45997 }
45998 return resultobj;
45999 fail:
46000 return NULL;
46001 }
46002
46003
46004 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46005 PyObject *obj;
46006 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46007 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
46008 return SWIG_Py_Void();
46009 }
46010
46011 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46012 return SWIG_Python_InitShadowInstance(args);
46013 }
46014
46015 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46016 PyObject *resultobj = 0;
46017 wxMenu *arg1 = (wxMenu *) NULL ;
46018 int arg2 = (int) wxID_SEPARATOR ;
46019 wxString const &arg3_defvalue = wxPyEmptyString ;
46020 wxString *arg3 = (wxString *) &arg3_defvalue ;
46021 wxString const &arg4_defvalue = wxPyEmptyString ;
46022 wxString *arg4 = (wxString *) &arg4_defvalue ;
46023 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
46024 wxMenu *arg6 = (wxMenu *) NULL ;
46025 wxMenuItem *result = 0 ;
46026 void *argp1 = 0 ;
46027 int res1 = 0 ;
46028 int val2 ;
46029 int ecode2 = 0 ;
46030 bool temp3 = false ;
46031 bool temp4 = false ;
46032 int val5 ;
46033 int ecode5 = 0 ;
46034 void *argp6 = 0 ;
46035 int res6 = 0 ;
46036 PyObject * obj0 = 0 ;
46037 PyObject * obj1 = 0 ;
46038 PyObject * obj2 = 0 ;
46039 PyObject * obj3 = 0 ;
46040 PyObject * obj4 = 0 ;
46041 PyObject * obj5 = 0 ;
46042 char * kwnames[] = {
46043 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
46044 };
46045
46046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46047 if (obj0) {
46048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
46049 if (!SWIG_IsOK(res1)) {
46050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
46051 }
46052 arg1 = reinterpret_cast< wxMenu * >(argp1);
46053 }
46054 if (obj1) {
46055 ecode2 = SWIG_AsVal_int(obj1, &val2);
46056 if (!SWIG_IsOK(ecode2)) {
46057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
46058 }
46059 arg2 = static_cast< int >(val2);
46060 }
46061 if (obj2) {
46062 {
46063 arg3 = wxString_in_helper(obj2);
46064 if (arg3 == NULL) SWIG_fail;
46065 temp3 = true;
46066 }
46067 }
46068 if (obj3) {
46069 {
46070 arg4 = wxString_in_helper(obj3);
46071 if (arg4 == NULL) SWIG_fail;
46072 temp4 = true;
46073 }
46074 }
46075 if (obj4) {
46076 ecode5 = SWIG_AsVal_int(obj4, &val5);
46077 if (!SWIG_IsOK(ecode5)) {
46078 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
46079 }
46080 arg5 = static_cast< wxItemKind >(val5);
46081 }
46082 if (obj5) {
46083 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
46084 if (!SWIG_IsOK(res6)) {
46085 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
46086 }
46087 arg6 = reinterpret_cast< wxMenu * >(argp6);
46088 }
46089 {
46090 PyThreadState* __tstate = wxPyBeginAllowThreads();
46091 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
46092 wxPyEndAllowThreads(__tstate);
46093 if (PyErr_Occurred()) SWIG_fail;
46094 }
46095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
46096 {
46097 if (temp3)
46098 delete arg3;
46099 }
46100 {
46101 if (temp4)
46102 delete arg4;
46103 }
46104 return resultobj;
46105 fail:
46106 {
46107 if (temp3)
46108 delete arg3;
46109 }
46110 {
46111 if (temp4)
46112 delete arg4;
46113 }
46114 return NULL;
46115 }
46116
46117
46118 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46119 PyObject *resultobj = 0;
46120 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46121 void *argp1 = 0 ;
46122 int res1 = 0 ;
46123 PyObject *swig_obj[1] ;
46124
46125 if (!args) SWIG_fail;
46126 swig_obj[0] = args;
46127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
46128 if (!SWIG_IsOK(res1)) {
46129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46130 }
46131 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46132 {
46133 PyThreadState* __tstate = wxPyBeginAllowThreads();
46134 delete arg1;
46135
46136 wxPyEndAllowThreads(__tstate);
46137 if (PyErr_Occurred()) SWIG_fail;
46138 }
46139 resultobj = SWIG_Py_Void();
46140 return resultobj;
46141 fail:
46142 return NULL;
46143 }
46144
46145
46146 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46147 PyObject *resultobj = 0;
46148 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46149 wxMenu *result = 0 ;
46150 void *argp1 = 0 ;
46151 int res1 = 0 ;
46152 PyObject *swig_obj[1] ;
46153
46154 if (!args) SWIG_fail;
46155 swig_obj[0] = args;
46156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46157 if (!SWIG_IsOK(res1)) {
46158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46159 }
46160 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46161 {
46162 PyThreadState* __tstate = wxPyBeginAllowThreads();
46163 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
46164 wxPyEndAllowThreads(__tstate);
46165 if (PyErr_Occurred()) SWIG_fail;
46166 }
46167 {
46168 resultobj = wxPyMake_wxObject(result, 0);
46169 }
46170 return resultobj;
46171 fail:
46172 return NULL;
46173 }
46174
46175
46176 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46177 PyObject *resultobj = 0;
46178 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46179 wxMenu *arg2 = (wxMenu *) 0 ;
46180 void *argp1 = 0 ;
46181 int res1 = 0 ;
46182 void *argp2 = 0 ;
46183 int res2 = 0 ;
46184 PyObject * obj0 = 0 ;
46185 PyObject * obj1 = 0 ;
46186 char * kwnames[] = {
46187 (char *) "self",(char *) "menu", NULL
46188 };
46189
46190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46192 if (!SWIG_IsOK(res1)) {
46193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46194 }
46195 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46196 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46197 if (!SWIG_IsOK(res2)) {
46198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46199 }
46200 arg2 = reinterpret_cast< wxMenu * >(argp2);
46201 {
46202 PyThreadState* __tstate = wxPyBeginAllowThreads();
46203 (arg1)->SetMenu(arg2);
46204 wxPyEndAllowThreads(__tstate);
46205 if (PyErr_Occurred()) SWIG_fail;
46206 }
46207 resultobj = SWIG_Py_Void();
46208 return resultobj;
46209 fail:
46210 return NULL;
46211 }
46212
46213
46214 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46215 PyObject *resultobj = 0;
46216 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46217 int arg2 ;
46218 void *argp1 = 0 ;
46219 int res1 = 0 ;
46220 int val2 ;
46221 int ecode2 = 0 ;
46222 PyObject * obj0 = 0 ;
46223 PyObject * obj1 = 0 ;
46224 char * kwnames[] = {
46225 (char *) "self",(char *) "id", NULL
46226 };
46227
46228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
46229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46230 if (!SWIG_IsOK(res1)) {
46231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46232 }
46233 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46234 ecode2 = SWIG_AsVal_int(obj1, &val2);
46235 if (!SWIG_IsOK(ecode2)) {
46236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
46237 }
46238 arg2 = static_cast< int >(val2);
46239 {
46240 PyThreadState* __tstate = wxPyBeginAllowThreads();
46241 (arg1)->SetId(arg2);
46242 wxPyEndAllowThreads(__tstate);
46243 if (PyErr_Occurred()) SWIG_fail;
46244 }
46245 resultobj = SWIG_Py_Void();
46246 return resultobj;
46247 fail:
46248 return NULL;
46249 }
46250
46251
46252 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46253 PyObject *resultobj = 0;
46254 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46255 int result;
46256 void *argp1 = 0 ;
46257 int res1 = 0 ;
46258 PyObject *swig_obj[1] ;
46259
46260 if (!args) SWIG_fail;
46261 swig_obj[0] = args;
46262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46263 if (!SWIG_IsOK(res1)) {
46264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46265 }
46266 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46267 {
46268 PyThreadState* __tstate = wxPyBeginAllowThreads();
46269 result = (int)((wxMenuItem const *)arg1)->GetId();
46270 wxPyEndAllowThreads(__tstate);
46271 if (PyErr_Occurred()) SWIG_fail;
46272 }
46273 resultobj = SWIG_From_int(static_cast< int >(result));
46274 return resultobj;
46275 fail:
46276 return NULL;
46277 }
46278
46279
46280 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46281 PyObject *resultobj = 0;
46282 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46283 bool result;
46284 void *argp1 = 0 ;
46285 int res1 = 0 ;
46286 PyObject *swig_obj[1] ;
46287
46288 if (!args) SWIG_fail;
46289 swig_obj[0] = args;
46290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46291 if (!SWIG_IsOK(res1)) {
46292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46293 }
46294 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46295 {
46296 PyThreadState* __tstate = wxPyBeginAllowThreads();
46297 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
46298 wxPyEndAllowThreads(__tstate);
46299 if (PyErr_Occurred()) SWIG_fail;
46300 }
46301 {
46302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46303 }
46304 return resultobj;
46305 fail:
46306 return NULL;
46307 }
46308
46309
46310 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46311 PyObject *resultobj = 0;
46312 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46313 wxString *arg2 = 0 ;
46314 void *argp1 = 0 ;
46315 int res1 = 0 ;
46316 bool temp2 = false ;
46317 PyObject * obj0 = 0 ;
46318 PyObject * obj1 = 0 ;
46319 char * kwnames[] = {
46320 (char *) "self",(char *) "str", NULL
46321 };
46322
46323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
46324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46325 if (!SWIG_IsOK(res1)) {
46326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46327 }
46328 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46329 {
46330 arg2 = wxString_in_helper(obj1);
46331 if (arg2 == NULL) SWIG_fail;
46332 temp2 = true;
46333 }
46334 {
46335 PyThreadState* __tstate = wxPyBeginAllowThreads();
46336 (arg1)->SetText((wxString const &)*arg2);
46337 wxPyEndAllowThreads(__tstate);
46338 if (PyErr_Occurred()) SWIG_fail;
46339 }
46340 resultobj = SWIG_Py_Void();
46341 {
46342 if (temp2)
46343 delete arg2;
46344 }
46345 return resultobj;
46346 fail:
46347 {
46348 if (temp2)
46349 delete arg2;
46350 }
46351 return NULL;
46352 }
46353
46354
46355 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46356 PyObject *resultobj = 0;
46357 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46358 wxString result;
46359 void *argp1 = 0 ;
46360 int res1 = 0 ;
46361 PyObject *swig_obj[1] ;
46362
46363 if (!args) SWIG_fail;
46364 swig_obj[0] = args;
46365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46366 if (!SWIG_IsOK(res1)) {
46367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46368 }
46369 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46370 {
46371 PyThreadState* __tstate = wxPyBeginAllowThreads();
46372 result = ((wxMenuItem const *)arg1)->GetLabel();
46373 wxPyEndAllowThreads(__tstate);
46374 if (PyErr_Occurred()) SWIG_fail;
46375 }
46376 {
46377 #if wxUSE_UNICODE
46378 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46379 #else
46380 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46381 #endif
46382 }
46383 return resultobj;
46384 fail:
46385 return NULL;
46386 }
46387
46388
46389 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46390 PyObject *resultobj = 0;
46391 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46392 wxString *result = 0 ;
46393 void *argp1 = 0 ;
46394 int res1 = 0 ;
46395 PyObject *swig_obj[1] ;
46396
46397 if (!args) SWIG_fail;
46398 swig_obj[0] = args;
46399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46400 if (!SWIG_IsOK(res1)) {
46401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46402 }
46403 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46404 {
46405 PyThreadState* __tstate = wxPyBeginAllowThreads();
46406 {
46407 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46408 result = (wxString *) &_result_ref;
46409 }
46410 wxPyEndAllowThreads(__tstate);
46411 if (PyErr_Occurred()) SWIG_fail;
46412 }
46413 {
46414 #if wxUSE_UNICODE
46415 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46416 #else
46417 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46418 #endif
46419 }
46420 return resultobj;
46421 fail:
46422 return NULL;
46423 }
46424
46425
46426 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46427 PyObject *resultobj = 0;
46428 wxString *arg1 = 0 ;
46429 wxString result;
46430 bool temp1 = false ;
46431 PyObject * obj0 = 0 ;
46432 char * kwnames[] = {
46433 (char *) "text", NULL
46434 };
46435
46436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46437 {
46438 arg1 = wxString_in_helper(obj0);
46439 if (arg1 == NULL) SWIG_fail;
46440 temp1 = true;
46441 }
46442 {
46443 PyThreadState* __tstate = wxPyBeginAllowThreads();
46444 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46445 wxPyEndAllowThreads(__tstate);
46446 if (PyErr_Occurred()) SWIG_fail;
46447 }
46448 {
46449 #if wxUSE_UNICODE
46450 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46451 #else
46452 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46453 #endif
46454 }
46455 {
46456 if (temp1)
46457 delete arg1;
46458 }
46459 return resultobj;
46460 fail:
46461 {
46462 if (temp1)
46463 delete arg1;
46464 }
46465 return NULL;
46466 }
46467
46468
46469 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46470 PyObject *resultobj = 0;
46471 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46472 wxItemKind result;
46473 void *argp1 = 0 ;
46474 int res1 = 0 ;
46475 PyObject *swig_obj[1] ;
46476
46477 if (!args) SWIG_fail;
46478 swig_obj[0] = args;
46479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46480 if (!SWIG_IsOK(res1)) {
46481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46482 }
46483 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46484 {
46485 PyThreadState* __tstate = wxPyBeginAllowThreads();
46486 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46487 wxPyEndAllowThreads(__tstate);
46488 if (PyErr_Occurred()) SWIG_fail;
46489 }
46490 resultobj = SWIG_From_int(static_cast< int >(result));
46491 return resultobj;
46492 fail:
46493 return NULL;
46494 }
46495
46496
46497 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46498 PyObject *resultobj = 0;
46499 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46500 wxItemKind arg2 ;
46501 void *argp1 = 0 ;
46502 int res1 = 0 ;
46503 int val2 ;
46504 int ecode2 = 0 ;
46505 PyObject * obj0 = 0 ;
46506 PyObject * obj1 = 0 ;
46507 char * kwnames[] = {
46508 (char *) "self",(char *) "kind", NULL
46509 };
46510
46511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46513 if (!SWIG_IsOK(res1)) {
46514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46515 }
46516 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46517 ecode2 = SWIG_AsVal_int(obj1, &val2);
46518 if (!SWIG_IsOK(ecode2)) {
46519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46520 }
46521 arg2 = static_cast< wxItemKind >(val2);
46522 {
46523 PyThreadState* __tstate = wxPyBeginAllowThreads();
46524 (arg1)->SetKind(arg2);
46525 wxPyEndAllowThreads(__tstate);
46526 if (PyErr_Occurred()) SWIG_fail;
46527 }
46528 resultobj = SWIG_Py_Void();
46529 return resultobj;
46530 fail:
46531 return NULL;
46532 }
46533
46534
46535 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46536 PyObject *resultobj = 0;
46537 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46538 bool arg2 ;
46539 void *argp1 = 0 ;
46540 int res1 = 0 ;
46541 bool val2 ;
46542 int ecode2 = 0 ;
46543 PyObject * obj0 = 0 ;
46544 PyObject * obj1 = 0 ;
46545 char * kwnames[] = {
46546 (char *) "self",(char *) "checkable", NULL
46547 };
46548
46549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46551 if (!SWIG_IsOK(res1)) {
46552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46553 }
46554 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46555 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46556 if (!SWIG_IsOK(ecode2)) {
46557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46558 }
46559 arg2 = static_cast< bool >(val2);
46560 {
46561 PyThreadState* __tstate = wxPyBeginAllowThreads();
46562 (arg1)->SetCheckable(arg2);
46563 wxPyEndAllowThreads(__tstate);
46564 if (PyErr_Occurred()) SWIG_fail;
46565 }
46566 resultobj = SWIG_Py_Void();
46567 return resultobj;
46568 fail:
46569 return NULL;
46570 }
46571
46572
46573 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46574 PyObject *resultobj = 0;
46575 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46576 bool result;
46577 void *argp1 = 0 ;
46578 int res1 = 0 ;
46579 PyObject *swig_obj[1] ;
46580
46581 if (!args) SWIG_fail;
46582 swig_obj[0] = args;
46583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46584 if (!SWIG_IsOK(res1)) {
46585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46586 }
46587 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46588 {
46589 PyThreadState* __tstate = wxPyBeginAllowThreads();
46590 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46591 wxPyEndAllowThreads(__tstate);
46592 if (PyErr_Occurred()) SWIG_fail;
46593 }
46594 {
46595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46596 }
46597 return resultobj;
46598 fail:
46599 return NULL;
46600 }
46601
46602
46603 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46604 PyObject *resultobj = 0;
46605 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46606 bool result;
46607 void *argp1 = 0 ;
46608 int res1 = 0 ;
46609 PyObject *swig_obj[1] ;
46610
46611 if (!args) SWIG_fail;
46612 swig_obj[0] = args;
46613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46614 if (!SWIG_IsOK(res1)) {
46615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46616 }
46617 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46618 {
46619 PyThreadState* __tstate = wxPyBeginAllowThreads();
46620 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46621 wxPyEndAllowThreads(__tstate);
46622 if (PyErr_Occurred()) SWIG_fail;
46623 }
46624 {
46625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46626 }
46627 return resultobj;
46628 fail:
46629 return NULL;
46630 }
46631
46632
46633 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46634 PyObject *resultobj = 0;
46635 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46636 wxMenu *arg2 = (wxMenu *) 0 ;
46637 void *argp1 = 0 ;
46638 int res1 = 0 ;
46639 void *argp2 = 0 ;
46640 int res2 = 0 ;
46641 PyObject * obj0 = 0 ;
46642 PyObject * obj1 = 0 ;
46643 char * kwnames[] = {
46644 (char *) "self",(char *) "menu", NULL
46645 };
46646
46647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46649 if (!SWIG_IsOK(res1)) {
46650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46651 }
46652 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46653 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46654 if (!SWIG_IsOK(res2)) {
46655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46656 }
46657 arg2 = reinterpret_cast< wxMenu * >(argp2);
46658 {
46659 PyThreadState* __tstate = wxPyBeginAllowThreads();
46660 (arg1)->SetSubMenu(arg2);
46661 wxPyEndAllowThreads(__tstate);
46662 if (PyErr_Occurred()) SWIG_fail;
46663 }
46664 resultobj = SWIG_Py_Void();
46665 return resultobj;
46666 fail:
46667 return NULL;
46668 }
46669
46670
46671 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46672 PyObject *resultobj = 0;
46673 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46674 wxMenu *result = 0 ;
46675 void *argp1 = 0 ;
46676 int res1 = 0 ;
46677 PyObject *swig_obj[1] ;
46678
46679 if (!args) SWIG_fail;
46680 swig_obj[0] = args;
46681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46682 if (!SWIG_IsOK(res1)) {
46683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46684 }
46685 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46686 {
46687 PyThreadState* __tstate = wxPyBeginAllowThreads();
46688 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46689 wxPyEndAllowThreads(__tstate);
46690 if (PyErr_Occurred()) SWIG_fail;
46691 }
46692 {
46693 resultobj = wxPyMake_wxObject(result, 0);
46694 }
46695 return resultobj;
46696 fail:
46697 return NULL;
46698 }
46699
46700
46701 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46702 PyObject *resultobj = 0;
46703 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46704 bool arg2 = (bool) true ;
46705 void *argp1 = 0 ;
46706 int res1 = 0 ;
46707 bool val2 ;
46708 int ecode2 = 0 ;
46709 PyObject * obj0 = 0 ;
46710 PyObject * obj1 = 0 ;
46711 char * kwnames[] = {
46712 (char *) "self",(char *) "enable", NULL
46713 };
46714
46715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46717 if (!SWIG_IsOK(res1)) {
46718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46719 }
46720 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46721 if (obj1) {
46722 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46723 if (!SWIG_IsOK(ecode2)) {
46724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46725 }
46726 arg2 = static_cast< bool >(val2);
46727 }
46728 {
46729 PyThreadState* __tstate = wxPyBeginAllowThreads();
46730 (arg1)->Enable(arg2);
46731 wxPyEndAllowThreads(__tstate);
46732 if (PyErr_Occurred()) SWIG_fail;
46733 }
46734 resultobj = SWIG_Py_Void();
46735 return resultobj;
46736 fail:
46737 return NULL;
46738 }
46739
46740
46741 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46742 PyObject *resultobj = 0;
46743 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46744 bool result;
46745 void *argp1 = 0 ;
46746 int res1 = 0 ;
46747 PyObject *swig_obj[1] ;
46748
46749 if (!args) SWIG_fail;
46750 swig_obj[0] = args;
46751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46752 if (!SWIG_IsOK(res1)) {
46753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46754 }
46755 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46756 {
46757 PyThreadState* __tstate = wxPyBeginAllowThreads();
46758 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46759 wxPyEndAllowThreads(__tstate);
46760 if (PyErr_Occurred()) SWIG_fail;
46761 }
46762 {
46763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46764 }
46765 return resultobj;
46766 fail:
46767 return NULL;
46768 }
46769
46770
46771 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46772 PyObject *resultobj = 0;
46773 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46774 bool arg2 = (bool) true ;
46775 void *argp1 = 0 ;
46776 int res1 = 0 ;
46777 bool val2 ;
46778 int ecode2 = 0 ;
46779 PyObject * obj0 = 0 ;
46780 PyObject * obj1 = 0 ;
46781 char * kwnames[] = {
46782 (char *) "self",(char *) "check", NULL
46783 };
46784
46785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46787 if (!SWIG_IsOK(res1)) {
46788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46789 }
46790 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46791 if (obj1) {
46792 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46793 if (!SWIG_IsOK(ecode2)) {
46794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46795 }
46796 arg2 = static_cast< bool >(val2);
46797 }
46798 {
46799 PyThreadState* __tstate = wxPyBeginAllowThreads();
46800 (arg1)->Check(arg2);
46801 wxPyEndAllowThreads(__tstate);
46802 if (PyErr_Occurred()) SWIG_fail;
46803 }
46804 resultobj = SWIG_Py_Void();
46805 return resultobj;
46806 fail:
46807 return NULL;
46808 }
46809
46810
46811 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46812 PyObject *resultobj = 0;
46813 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46814 bool result;
46815 void *argp1 = 0 ;
46816 int res1 = 0 ;
46817 PyObject *swig_obj[1] ;
46818
46819 if (!args) SWIG_fail;
46820 swig_obj[0] = args;
46821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46822 if (!SWIG_IsOK(res1)) {
46823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46824 }
46825 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46826 {
46827 PyThreadState* __tstate = wxPyBeginAllowThreads();
46828 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46829 wxPyEndAllowThreads(__tstate);
46830 if (PyErr_Occurred()) SWIG_fail;
46831 }
46832 {
46833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46834 }
46835 return resultobj;
46836 fail:
46837 return NULL;
46838 }
46839
46840
46841 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46842 PyObject *resultobj = 0;
46843 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46844 void *argp1 = 0 ;
46845 int res1 = 0 ;
46846 PyObject *swig_obj[1] ;
46847
46848 if (!args) SWIG_fail;
46849 swig_obj[0] = args;
46850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46851 if (!SWIG_IsOK(res1)) {
46852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46853 }
46854 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46855 {
46856 PyThreadState* __tstate = wxPyBeginAllowThreads();
46857 (arg1)->Toggle();
46858 wxPyEndAllowThreads(__tstate);
46859 if (PyErr_Occurred()) SWIG_fail;
46860 }
46861 resultobj = SWIG_Py_Void();
46862 return resultobj;
46863 fail:
46864 return NULL;
46865 }
46866
46867
46868 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46869 PyObject *resultobj = 0;
46870 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46871 wxString *arg2 = 0 ;
46872 void *argp1 = 0 ;
46873 int res1 = 0 ;
46874 bool temp2 = false ;
46875 PyObject * obj0 = 0 ;
46876 PyObject * obj1 = 0 ;
46877 char * kwnames[] = {
46878 (char *) "self",(char *) "str", NULL
46879 };
46880
46881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46883 if (!SWIG_IsOK(res1)) {
46884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46885 }
46886 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46887 {
46888 arg2 = wxString_in_helper(obj1);
46889 if (arg2 == NULL) SWIG_fail;
46890 temp2 = true;
46891 }
46892 {
46893 PyThreadState* __tstate = wxPyBeginAllowThreads();
46894 (arg1)->SetHelp((wxString const &)*arg2);
46895 wxPyEndAllowThreads(__tstate);
46896 if (PyErr_Occurred()) SWIG_fail;
46897 }
46898 resultobj = SWIG_Py_Void();
46899 {
46900 if (temp2)
46901 delete arg2;
46902 }
46903 return resultobj;
46904 fail:
46905 {
46906 if (temp2)
46907 delete arg2;
46908 }
46909 return NULL;
46910 }
46911
46912
46913 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46914 PyObject *resultobj = 0;
46915 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46916 wxString *result = 0 ;
46917 void *argp1 = 0 ;
46918 int res1 = 0 ;
46919 PyObject *swig_obj[1] ;
46920
46921 if (!args) SWIG_fail;
46922 swig_obj[0] = args;
46923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46924 if (!SWIG_IsOK(res1)) {
46925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46926 }
46927 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46928 {
46929 PyThreadState* __tstate = wxPyBeginAllowThreads();
46930 {
46931 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46932 result = (wxString *) &_result_ref;
46933 }
46934 wxPyEndAllowThreads(__tstate);
46935 if (PyErr_Occurred()) SWIG_fail;
46936 }
46937 {
46938 #if wxUSE_UNICODE
46939 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46940 #else
46941 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46942 #endif
46943 }
46944 return resultobj;
46945 fail:
46946 return NULL;
46947 }
46948
46949
46950 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46951 PyObject *resultobj = 0;
46952 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46953 wxAcceleratorEntry *result = 0 ;
46954 void *argp1 = 0 ;
46955 int res1 = 0 ;
46956 PyObject *swig_obj[1] ;
46957
46958 if (!args) SWIG_fail;
46959 swig_obj[0] = args;
46960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46961 if (!SWIG_IsOK(res1)) {
46962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46963 }
46964 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46965 {
46966 PyThreadState* __tstate = wxPyBeginAllowThreads();
46967 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46968 wxPyEndAllowThreads(__tstate);
46969 if (PyErr_Occurred()) SWIG_fail;
46970 }
46971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46972 return resultobj;
46973 fail:
46974 return NULL;
46975 }
46976
46977
46978 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46979 PyObject *resultobj = 0;
46980 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46981 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46982 void *argp1 = 0 ;
46983 int res1 = 0 ;
46984 void *argp2 = 0 ;
46985 int res2 = 0 ;
46986 PyObject * obj0 = 0 ;
46987 PyObject * obj1 = 0 ;
46988 char * kwnames[] = {
46989 (char *) "self",(char *) "accel", NULL
46990 };
46991
46992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46994 if (!SWIG_IsOK(res1)) {
46995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46996 }
46997 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46998 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46999 if (!SWIG_IsOK(res2)) {
47000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
47001 }
47002 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
47003 {
47004 PyThreadState* __tstate = wxPyBeginAllowThreads();
47005 (arg1)->SetAccel(arg2);
47006 wxPyEndAllowThreads(__tstate);
47007 if (PyErr_Occurred()) SWIG_fail;
47008 }
47009 resultobj = SWIG_Py_Void();
47010 return resultobj;
47011 fail:
47012 return NULL;
47013 }
47014
47015
47016 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47017 PyObject *resultobj = 0;
47018 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47019 wxBitmap *arg2 = 0 ;
47020 void *argp1 = 0 ;
47021 int res1 = 0 ;
47022 void *argp2 = 0 ;
47023 int res2 = 0 ;
47024 PyObject * obj0 = 0 ;
47025 PyObject * obj1 = 0 ;
47026 char * kwnames[] = {
47027 (char *) "self",(char *) "bitmap", NULL
47028 };
47029
47030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47032 if (!SWIG_IsOK(res1)) {
47033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47034 }
47035 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47036 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47037 if (!SWIG_IsOK(res2)) {
47038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47039 }
47040 if (!argp2) {
47041 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47042 }
47043 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47044 {
47045 PyThreadState* __tstate = wxPyBeginAllowThreads();
47046 (arg1)->SetBitmap((wxBitmap const &)*arg2);
47047 wxPyEndAllowThreads(__tstate);
47048 if (PyErr_Occurred()) SWIG_fail;
47049 }
47050 resultobj = SWIG_Py_Void();
47051 return resultobj;
47052 fail:
47053 return NULL;
47054 }
47055
47056
47057 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47058 PyObject *resultobj = 0;
47059 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47060 wxBitmap *result = 0 ;
47061 void *argp1 = 0 ;
47062 int res1 = 0 ;
47063 PyObject *swig_obj[1] ;
47064
47065 if (!args) SWIG_fail;
47066 swig_obj[0] = args;
47067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47068 if (!SWIG_IsOK(res1)) {
47069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47070 }
47071 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47072 {
47073 PyThreadState* __tstate = wxPyBeginAllowThreads();
47074 {
47075 wxBitmap const &_result_ref = (arg1)->GetBitmap();
47076 result = (wxBitmap *) &_result_ref;
47077 }
47078 wxPyEndAllowThreads(__tstate);
47079 if (PyErr_Occurred()) SWIG_fail;
47080 }
47081 {
47082 wxBitmap* resultptr = new wxBitmap(*result);
47083 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47084 }
47085 return resultobj;
47086 fail:
47087 return NULL;
47088 }
47089
47090
47091 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47092 PyObject *resultobj = 0;
47093 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47094 wxFont *arg2 = 0 ;
47095 void *argp1 = 0 ;
47096 int res1 = 0 ;
47097 void *argp2 = 0 ;
47098 int res2 = 0 ;
47099 PyObject * obj0 = 0 ;
47100 PyObject * obj1 = 0 ;
47101 char * kwnames[] = {
47102 (char *) "self",(char *) "font", NULL
47103 };
47104
47105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
47106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47107 if (!SWIG_IsOK(res1)) {
47108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47109 }
47110 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47111 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
47112 if (!SWIG_IsOK(res2)) {
47113 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47114 }
47115 if (!argp2) {
47116 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47117 }
47118 arg2 = reinterpret_cast< wxFont * >(argp2);
47119 {
47120 PyThreadState* __tstate = wxPyBeginAllowThreads();
47121 (arg1)->SetFont((wxFont const &)*arg2);
47122 wxPyEndAllowThreads(__tstate);
47123 if (PyErr_Occurred()) SWIG_fail;
47124 }
47125 resultobj = SWIG_Py_Void();
47126 return resultobj;
47127 fail:
47128 return NULL;
47129 }
47130
47131
47132 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47133 PyObject *resultobj = 0;
47134 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47135 wxFont result;
47136 void *argp1 = 0 ;
47137 int res1 = 0 ;
47138 PyObject *swig_obj[1] ;
47139
47140 if (!args) SWIG_fail;
47141 swig_obj[0] = args;
47142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47143 if (!SWIG_IsOK(res1)) {
47144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47145 }
47146 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47147 {
47148 PyThreadState* __tstate = wxPyBeginAllowThreads();
47149 result = (arg1)->GetFont();
47150 wxPyEndAllowThreads(__tstate);
47151 if (PyErr_Occurred()) SWIG_fail;
47152 }
47153 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
47154 return resultobj;
47155 fail:
47156 return NULL;
47157 }
47158
47159
47160 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47161 PyObject *resultobj = 0;
47162 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47163 wxColour *arg2 = 0 ;
47164 void *argp1 = 0 ;
47165 int res1 = 0 ;
47166 wxColour temp2 ;
47167 PyObject * obj0 = 0 ;
47168 PyObject * obj1 = 0 ;
47169 char * kwnames[] = {
47170 (char *) "self",(char *) "colText", NULL
47171 };
47172
47173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
47174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47175 if (!SWIG_IsOK(res1)) {
47176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47177 }
47178 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47179 {
47180 arg2 = &temp2;
47181 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47182 }
47183 {
47184 PyThreadState* __tstate = wxPyBeginAllowThreads();
47185 (arg1)->SetTextColour((wxColour const &)*arg2);
47186 wxPyEndAllowThreads(__tstate);
47187 if (PyErr_Occurred()) SWIG_fail;
47188 }
47189 resultobj = SWIG_Py_Void();
47190 return resultobj;
47191 fail:
47192 return NULL;
47193 }
47194
47195
47196 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47197 PyObject *resultobj = 0;
47198 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47199 wxColour result;
47200 void *argp1 = 0 ;
47201 int res1 = 0 ;
47202 PyObject *swig_obj[1] ;
47203
47204 if (!args) SWIG_fail;
47205 swig_obj[0] = args;
47206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47207 if (!SWIG_IsOK(res1)) {
47208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47209 }
47210 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47211 {
47212 PyThreadState* __tstate = wxPyBeginAllowThreads();
47213 result = (arg1)->GetTextColour();
47214 wxPyEndAllowThreads(__tstate);
47215 if (PyErr_Occurred()) SWIG_fail;
47216 }
47217 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47218 return resultobj;
47219 fail:
47220 return NULL;
47221 }
47222
47223
47224 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47225 PyObject *resultobj = 0;
47226 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47227 wxColour *arg2 = 0 ;
47228 void *argp1 = 0 ;
47229 int res1 = 0 ;
47230 wxColour temp2 ;
47231 PyObject * obj0 = 0 ;
47232 PyObject * obj1 = 0 ;
47233 char * kwnames[] = {
47234 (char *) "self",(char *) "colBack", NULL
47235 };
47236
47237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
47238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47239 if (!SWIG_IsOK(res1)) {
47240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47241 }
47242 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47243 {
47244 arg2 = &temp2;
47245 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47246 }
47247 {
47248 PyThreadState* __tstate = wxPyBeginAllowThreads();
47249 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
47250 wxPyEndAllowThreads(__tstate);
47251 if (PyErr_Occurred()) SWIG_fail;
47252 }
47253 resultobj = SWIG_Py_Void();
47254 return resultobj;
47255 fail:
47256 return NULL;
47257 }
47258
47259
47260 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47261 PyObject *resultobj = 0;
47262 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47263 wxColour result;
47264 void *argp1 = 0 ;
47265 int res1 = 0 ;
47266 PyObject *swig_obj[1] ;
47267
47268 if (!args) SWIG_fail;
47269 swig_obj[0] = args;
47270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47271 if (!SWIG_IsOK(res1)) {
47272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47273 }
47274 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47275 {
47276 PyThreadState* __tstate = wxPyBeginAllowThreads();
47277 result = (arg1)->GetBackgroundColour();
47278 wxPyEndAllowThreads(__tstate);
47279 if (PyErr_Occurred()) SWIG_fail;
47280 }
47281 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47282 return resultobj;
47283 fail:
47284 return NULL;
47285 }
47286
47287
47288 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47289 PyObject *resultobj = 0;
47290 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47291 wxBitmap *arg2 = 0 ;
47292 wxBitmap const &arg3_defvalue = wxNullBitmap ;
47293 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
47294 void *argp1 = 0 ;
47295 int res1 = 0 ;
47296 void *argp2 = 0 ;
47297 int res2 = 0 ;
47298 void *argp3 = 0 ;
47299 int res3 = 0 ;
47300 PyObject * obj0 = 0 ;
47301 PyObject * obj1 = 0 ;
47302 PyObject * obj2 = 0 ;
47303 char * kwnames[] = {
47304 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
47305 };
47306
47307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47309 if (!SWIG_IsOK(res1)) {
47310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47311 }
47312 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47313 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47314 if (!SWIG_IsOK(res2)) {
47315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47316 }
47317 if (!argp2) {
47318 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47319 }
47320 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47321 if (obj2) {
47322 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
47323 if (!SWIG_IsOK(res3)) {
47324 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47325 }
47326 if (!argp3) {
47327 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47328 }
47329 arg3 = reinterpret_cast< wxBitmap * >(argp3);
47330 }
47331 {
47332 PyThreadState* __tstate = wxPyBeginAllowThreads();
47333 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
47334 wxPyEndAllowThreads(__tstate);
47335 if (PyErr_Occurred()) SWIG_fail;
47336 }
47337 resultobj = SWIG_Py_Void();
47338 return resultobj;
47339 fail:
47340 return NULL;
47341 }
47342
47343
47344 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47345 PyObject *resultobj = 0;
47346 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47347 wxBitmap *arg2 = 0 ;
47348 void *argp1 = 0 ;
47349 int res1 = 0 ;
47350 void *argp2 = 0 ;
47351 int res2 = 0 ;
47352 PyObject * obj0 = 0 ;
47353 PyObject * obj1 = 0 ;
47354 char * kwnames[] = {
47355 (char *) "self",(char *) "bmpDisabled", NULL
47356 };
47357
47358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47360 if (!SWIG_IsOK(res1)) {
47361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47362 }
47363 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47364 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47365 if (!SWIG_IsOK(res2)) {
47366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47367 }
47368 if (!argp2) {
47369 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47370 }
47371 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47372 {
47373 PyThreadState* __tstate = wxPyBeginAllowThreads();
47374 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
47375 wxPyEndAllowThreads(__tstate);
47376 if (PyErr_Occurred()) SWIG_fail;
47377 }
47378 resultobj = SWIG_Py_Void();
47379 return resultobj;
47380 fail:
47381 return NULL;
47382 }
47383
47384
47385 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47386 PyObject *resultobj = 0;
47387 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47388 wxBitmap *result = 0 ;
47389 void *argp1 = 0 ;
47390 int res1 = 0 ;
47391 PyObject *swig_obj[1] ;
47392
47393 if (!args) SWIG_fail;
47394 swig_obj[0] = args;
47395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47396 if (!SWIG_IsOK(res1)) {
47397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47398 }
47399 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47400 {
47401 PyThreadState* __tstate = wxPyBeginAllowThreads();
47402 {
47403 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
47404 result = (wxBitmap *) &_result_ref;
47405 }
47406 wxPyEndAllowThreads(__tstate);
47407 if (PyErr_Occurred()) SWIG_fail;
47408 }
47409 {
47410 wxBitmap* resultptr = new wxBitmap(*result);
47411 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47412 }
47413 return resultobj;
47414 fail:
47415 return NULL;
47416 }
47417
47418
47419 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47420 PyObject *resultobj = 0;
47421 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47422 int arg2 ;
47423 void *argp1 = 0 ;
47424 int res1 = 0 ;
47425 int val2 ;
47426 int ecode2 = 0 ;
47427 PyObject * obj0 = 0 ;
47428 PyObject * obj1 = 0 ;
47429 char * kwnames[] = {
47430 (char *) "self",(char *) "nWidth", NULL
47431 };
47432
47433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47435 if (!SWIG_IsOK(res1)) {
47436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47437 }
47438 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47439 ecode2 = SWIG_AsVal_int(obj1, &val2);
47440 if (!SWIG_IsOK(ecode2)) {
47441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47442 }
47443 arg2 = static_cast< int >(val2);
47444 {
47445 PyThreadState* __tstate = wxPyBeginAllowThreads();
47446 (arg1)->SetMarginWidth(arg2);
47447 wxPyEndAllowThreads(__tstate);
47448 if (PyErr_Occurred()) SWIG_fail;
47449 }
47450 resultobj = SWIG_Py_Void();
47451 return resultobj;
47452 fail:
47453 return NULL;
47454 }
47455
47456
47457 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47458 PyObject *resultobj = 0;
47459 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47460 int result;
47461 void *argp1 = 0 ;
47462 int res1 = 0 ;
47463 PyObject *swig_obj[1] ;
47464
47465 if (!args) SWIG_fail;
47466 swig_obj[0] = args;
47467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47468 if (!SWIG_IsOK(res1)) {
47469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47470 }
47471 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47472 {
47473 PyThreadState* __tstate = wxPyBeginAllowThreads();
47474 result = (int)(arg1)->GetMarginWidth();
47475 wxPyEndAllowThreads(__tstate);
47476 if (PyErr_Occurred()) SWIG_fail;
47477 }
47478 resultobj = SWIG_From_int(static_cast< int >(result));
47479 return resultobj;
47480 fail:
47481 return NULL;
47482 }
47483
47484
47485 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47486 PyObject *resultobj = 0;
47487 int result;
47488
47489 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47490 {
47491 PyThreadState* __tstate = wxPyBeginAllowThreads();
47492 result = (int)wxMenuItem::GetDefaultMarginWidth();
47493 wxPyEndAllowThreads(__tstate);
47494 if (PyErr_Occurred()) SWIG_fail;
47495 }
47496 resultobj = SWIG_From_int(static_cast< int >(result));
47497 return resultobj;
47498 fail:
47499 return NULL;
47500 }
47501
47502
47503 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47504 PyObject *resultobj = 0;
47505 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47506 bool result;
47507 void *argp1 = 0 ;
47508 int res1 = 0 ;
47509 PyObject *swig_obj[1] ;
47510
47511 if (!args) SWIG_fail;
47512 swig_obj[0] = args;
47513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47514 if (!SWIG_IsOK(res1)) {
47515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47516 }
47517 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47518 {
47519 PyThreadState* __tstate = wxPyBeginAllowThreads();
47520 result = (bool)(arg1)->IsOwnerDrawn();
47521 wxPyEndAllowThreads(__tstate);
47522 if (PyErr_Occurred()) SWIG_fail;
47523 }
47524 {
47525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47526 }
47527 return resultobj;
47528 fail:
47529 return NULL;
47530 }
47531
47532
47533 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47534 PyObject *resultobj = 0;
47535 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47536 bool arg2 = (bool) true ;
47537 void *argp1 = 0 ;
47538 int res1 = 0 ;
47539 bool val2 ;
47540 int ecode2 = 0 ;
47541 PyObject * obj0 = 0 ;
47542 PyObject * obj1 = 0 ;
47543 char * kwnames[] = {
47544 (char *) "self",(char *) "ownerDrawn", NULL
47545 };
47546
47547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47549 if (!SWIG_IsOK(res1)) {
47550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47551 }
47552 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47553 if (obj1) {
47554 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47555 if (!SWIG_IsOK(ecode2)) {
47556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47557 }
47558 arg2 = static_cast< bool >(val2);
47559 }
47560 {
47561 PyThreadState* __tstate = wxPyBeginAllowThreads();
47562 (arg1)->SetOwnerDrawn(arg2);
47563 wxPyEndAllowThreads(__tstate);
47564 if (PyErr_Occurred()) SWIG_fail;
47565 }
47566 resultobj = SWIG_Py_Void();
47567 return resultobj;
47568 fail:
47569 return NULL;
47570 }
47571
47572
47573 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47574 PyObject *resultobj = 0;
47575 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47576 void *argp1 = 0 ;
47577 int res1 = 0 ;
47578 PyObject *swig_obj[1] ;
47579
47580 if (!args) SWIG_fail;
47581 swig_obj[0] = args;
47582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47583 if (!SWIG_IsOK(res1)) {
47584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47585 }
47586 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47587 {
47588 PyThreadState* __tstate = wxPyBeginAllowThreads();
47589 (arg1)->ResetOwnerDrawn();
47590 wxPyEndAllowThreads(__tstate);
47591 if (PyErr_Occurred()) SWIG_fail;
47592 }
47593 resultobj = SWIG_Py_Void();
47594 return resultobj;
47595 fail:
47596 return NULL;
47597 }
47598
47599
47600 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47601 PyObject *obj;
47602 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47603 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47604 return SWIG_Py_Void();
47605 }
47606
47607 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47608 return SWIG_Python_InitShadowInstance(args);
47609 }
47610
47611 SWIGINTERN int ControlNameStr_set(PyObject *) {
47612 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47613 return 1;
47614 }
47615
47616
47617 SWIGINTERN PyObject *ControlNameStr_get(void) {
47618 PyObject *pyobj = 0;
47619
47620 {
47621 #if wxUSE_UNICODE
47622 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47623 #else
47624 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47625 #endif
47626 }
47627 return pyobj;
47628 }
47629
47630
47631 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47632 PyObject *resultobj = 0;
47633 wxWindow *arg1 = (wxWindow *) 0 ;
47634 int arg2 = (int) -1 ;
47635 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47636 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47637 wxSize const &arg4_defvalue = wxDefaultSize ;
47638 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47639 long arg5 = (long) 0 ;
47640 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47641 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47642 wxString const &arg7_defvalue = wxPyControlNameStr ;
47643 wxString *arg7 = (wxString *) &arg7_defvalue ;
47644 wxControl *result = 0 ;
47645 void *argp1 = 0 ;
47646 int res1 = 0 ;
47647 int val2 ;
47648 int ecode2 = 0 ;
47649 wxPoint temp3 ;
47650 wxSize temp4 ;
47651 long val5 ;
47652 int ecode5 = 0 ;
47653 void *argp6 = 0 ;
47654 int res6 = 0 ;
47655 bool temp7 = false ;
47656 PyObject * obj0 = 0 ;
47657 PyObject * obj1 = 0 ;
47658 PyObject * obj2 = 0 ;
47659 PyObject * obj3 = 0 ;
47660 PyObject * obj4 = 0 ;
47661 PyObject * obj5 = 0 ;
47662 PyObject * obj6 = 0 ;
47663 char * kwnames[] = {
47664 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47665 };
47666
47667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47669 if (!SWIG_IsOK(res1)) {
47670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47671 }
47672 arg1 = reinterpret_cast< wxWindow * >(argp1);
47673 if (obj1) {
47674 ecode2 = SWIG_AsVal_int(obj1, &val2);
47675 if (!SWIG_IsOK(ecode2)) {
47676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47677 }
47678 arg2 = static_cast< int >(val2);
47679 }
47680 if (obj2) {
47681 {
47682 arg3 = &temp3;
47683 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47684 }
47685 }
47686 if (obj3) {
47687 {
47688 arg4 = &temp4;
47689 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47690 }
47691 }
47692 if (obj4) {
47693 ecode5 = SWIG_AsVal_long(obj4, &val5);
47694 if (!SWIG_IsOK(ecode5)) {
47695 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47696 }
47697 arg5 = static_cast< long >(val5);
47698 }
47699 if (obj5) {
47700 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47701 if (!SWIG_IsOK(res6)) {
47702 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47703 }
47704 if (!argp6) {
47705 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47706 }
47707 arg6 = reinterpret_cast< wxValidator * >(argp6);
47708 }
47709 if (obj6) {
47710 {
47711 arg7 = wxString_in_helper(obj6);
47712 if (arg7 == NULL) SWIG_fail;
47713 temp7 = true;
47714 }
47715 }
47716 {
47717 if (!wxPyCheckForApp()) SWIG_fail;
47718 PyThreadState* __tstate = wxPyBeginAllowThreads();
47719 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47720 wxPyEndAllowThreads(__tstate);
47721 if (PyErr_Occurred()) SWIG_fail;
47722 }
47723 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47724 {
47725 if (temp7)
47726 delete arg7;
47727 }
47728 return resultobj;
47729 fail:
47730 {
47731 if (temp7)
47732 delete arg7;
47733 }
47734 return NULL;
47735 }
47736
47737
47738 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47739 PyObject *resultobj = 0;
47740 wxControl *result = 0 ;
47741
47742 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47743 {
47744 if (!wxPyCheckForApp()) SWIG_fail;
47745 PyThreadState* __tstate = wxPyBeginAllowThreads();
47746 result = (wxControl *)new wxControl();
47747 wxPyEndAllowThreads(__tstate);
47748 if (PyErr_Occurred()) SWIG_fail;
47749 }
47750 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47751 return resultobj;
47752 fail:
47753 return NULL;
47754 }
47755
47756
47757 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47758 PyObject *resultobj = 0;
47759 wxControl *arg1 = (wxControl *) 0 ;
47760 wxWindow *arg2 = (wxWindow *) 0 ;
47761 int arg3 = (int) -1 ;
47762 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47763 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47764 wxSize const &arg5_defvalue = wxDefaultSize ;
47765 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47766 long arg6 = (long) 0 ;
47767 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47768 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47769 wxString const &arg8_defvalue = wxPyControlNameStr ;
47770 wxString *arg8 = (wxString *) &arg8_defvalue ;
47771 bool result;
47772 void *argp1 = 0 ;
47773 int res1 = 0 ;
47774 void *argp2 = 0 ;
47775 int res2 = 0 ;
47776 int val3 ;
47777 int ecode3 = 0 ;
47778 wxPoint temp4 ;
47779 wxSize temp5 ;
47780 long val6 ;
47781 int ecode6 = 0 ;
47782 void *argp7 = 0 ;
47783 int res7 = 0 ;
47784 bool temp8 = false ;
47785 PyObject * obj0 = 0 ;
47786 PyObject * obj1 = 0 ;
47787 PyObject * obj2 = 0 ;
47788 PyObject * obj3 = 0 ;
47789 PyObject * obj4 = 0 ;
47790 PyObject * obj5 = 0 ;
47791 PyObject * obj6 = 0 ;
47792 PyObject * obj7 = 0 ;
47793 char * kwnames[] = {
47794 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47795 };
47796
47797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47799 if (!SWIG_IsOK(res1)) {
47800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47801 }
47802 arg1 = reinterpret_cast< wxControl * >(argp1);
47803 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47804 if (!SWIG_IsOK(res2)) {
47805 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47806 }
47807 arg2 = reinterpret_cast< wxWindow * >(argp2);
47808 if (obj2) {
47809 ecode3 = SWIG_AsVal_int(obj2, &val3);
47810 if (!SWIG_IsOK(ecode3)) {
47811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47812 }
47813 arg3 = static_cast< int >(val3);
47814 }
47815 if (obj3) {
47816 {
47817 arg4 = &temp4;
47818 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47819 }
47820 }
47821 if (obj4) {
47822 {
47823 arg5 = &temp5;
47824 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47825 }
47826 }
47827 if (obj5) {
47828 ecode6 = SWIG_AsVal_long(obj5, &val6);
47829 if (!SWIG_IsOK(ecode6)) {
47830 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47831 }
47832 arg6 = static_cast< long >(val6);
47833 }
47834 if (obj6) {
47835 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47836 if (!SWIG_IsOK(res7)) {
47837 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47838 }
47839 if (!argp7) {
47840 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47841 }
47842 arg7 = reinterpret_cast< wxValidator * >(argp7);
47843 }
47844 if (obj7) {
47845 {
47846 arg8 = wxString_in_helper(obj7);
47847 if (arg8 == NULL) SWIG_fail;
47848 temp8 = true;
47849 }
47850 }
47851 {
47852 PyThreadState* __tstate = wxPyBeginAllowThreads();
47853 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47854 wxPyEndAllowThreads(__tstate);
47855 if (PyErr_Occurred()) SWIG_fail;
47856 }
47857 {
47858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47859 }
47860 {
47861 if (temp8)
47862 delete arg8;
47863 }
47864 return resultobj;
47865 fail:
47866 {
47867 if (temp8)
47868 delete arg8;
47869 }
47870 return NULL;
47871 }
47872
47873
47874 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47875 PyObject *resultobj = 0;
47876 wxControl *arg1 = (wxControl *) 0 ;
47877 int result;
47878 void *argp1 = 0 ;
47879 int res1 = 0 ;
47880 PyObject *swig_obj[1] ;
47881
47882 if (!args) SWIG_fail;
47883 swig_obj[0] = args;
47884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47885 if (!SWIG_IsOK(res1)) {
47886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47887 }
47888 arg1 = reinterpret_cast< wxControl * >(argp1);
47889 {
47890 PyThreadState* __tstate = wxPyBeginAllowThreads();
47891 result = (int)((wxControl const *)arg1)->GetAlignment();
47892 wxPyEndAllowThreads(__tstate);
47893 if (PyErr_Occurred()) SWIG_fail;
47894 }
47895 resultobj = SWIG_From_int(static_cast< int >(result));
47896 return resultobj;
47897 fail:
47898 return NULL;
47899 }
47900
47901
47902 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47903 PyObject *resultobj = 0;
47904 wxControl *arg1 = (wxControl *) 0 ;
47905 wxString result;
47906 void *argp1 = 0 ;
47907 int res1 = 0 ;
47908 PyObject *swig_obj[1] ;
47909
47910 if (!args) SWIG_fail;
47911 swig_obj[0] = args;
47912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47913 if (!SWIG_IsOK(res1)) {
47914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47915 }
47916 arg1 = reinterpret_cast< wxControl * >(argp1);
47917 {
47918 PyThreadState* __tstate = wxPyBeginAllowThreads();
47919 result = ((wxControl const *)arg1)->GetLabelText();
47920 wxPyEndAllowThreads(__tstate);
47921 if (PyErr_Occurred()) SWIG_fail;
47922 }
47923 {
47924 #if wxUSE_UNICODE
47925 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47926 #else
47927 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47928 #endif
47929 }
47930 return resultobj;
47931 fail:
47932 return NULL;
47933 }
47934
47935
47936 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47937 PyObject *resultobj = 0;
47938 wxControl *arg1 = (wxControl *) 0 ;
47939 wxCommandEvent *arg2 = 0 ;
47940 void *argp1 = 0 ;
47941 int res1 = 0 ;
47942 void *argp2 = 0 ;
47943 int res2 = 0 ;
47944 PyObject * obj0 = 0 ;
47945 PyObject * obj1 = 0 ;
47946 char * kwnames[] = {
47947 (char *) "self",(char *) "event", NULL
47948 };
47949
47950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47952 if (!SWIG_IsOK(res1)) {
47953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47954 }
47955 arg1 = reinterpret_cast< wxControl * >(argp1);
47956 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47957 if (!SWIG_IsOK(res2)) {
47958 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47959 }
47960 if (!argp2) {
47961 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47962 }
47963 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47964 {
47965 PyThreadState* __tstate = wxPyBeginAllowThreads();
47966 (arg1)->Command(*arg2);
47967 wxPyEndAllowThreads(__tstate);
47968 if (PyErr_Occurred()) SWIG_fail;
47969 }
47970 resultobj = SWIG_Py_Void();
47971 return resultobj;
47972 fail:
47973 return NULL;
47974 }
47975
47976
47977 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47978 PyObject *resultobj = 0;
47979 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47980 SwigValueWrapper<wxVisualAttributes > result;
47981 int val1 ;
47982 int ecode1 = 0 ;
47983 PyObject * obj0 = 0 ;
47984 char * kwnames[] = {
47985 (char *) "variant", NULL
47986 };
47987
47988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47989 if (obj0) {
47990 ecode1 = SWIG_AsVal_int(obj0, &val1);
47991 if (!SWIG_IsOK(ecode1)) {
47992 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47993 }
47994 arg1 = static_cast< wxWindowVariant >(val1);
47995 }
47996 {
47997 if (!wxPyCheckForApp()) SWIG_fail;
47998 PyThreadState* __tstate = wxPyBeginAllowThreads();
47999 result = wxControl::GetClassDefaultAttributes(arg1);
48000 wxPyEndAllowThreads(__tstate);
48001 if (PyErr_Occurred()) SWIG_fail;
48002 }
48003 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
48004 return resultobj;
48005 fail:
48006 return NULL;
48007 }
48008
48009
48010 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48011 PyObject *obj;
48012 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48013 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
48014 return SWIG_Py_Void();
48015 }
48016
48017 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48018 return SWIG_Python_InitShadowInstance(args);
48019 }
48020
48021 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48022 PyObject *resultobj = 0;
48023 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48024 wxString *arg2 = 0 ;
48025 PyObject *arg3 = (PyObject *) NULL ;
48026 int result;
48027 void *argp1 = 0 ;
48028 int res1 = 0 ;
48029 bool temp2 = false ;
48030 PyObject * obj0 = 0 ;
48031 PyObject * obj1 = 0 ;
48032 PyObject * obj2 = 0 ;
48033 char * kwnames[] = {
48034 (char *) "self",(char *) "item",(char *) "clientData", NULL
48035 };
48036
48037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48039 if (!SWIG_IsOK(res1)) {
48040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48041 }
48042 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48043 {
48044 arg2 = wxString_in_helper(obj1);
48045 if (arg2 == NULL) SWIG_fail;
48046 temp2 = true;
48047 }
48048 if (obj2) {
48049 arg3 = obj2;
48050 }
48051 {
48052 PyThreadState* __tstate = wxPyBeginAllowThreads();
48053 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
48054 wxPyEndAllowThreads(__tstate);
48055 if (PyErr_Occurred()) SWIG_fail;
48056 }
48057 resultobj = SWIG_From_int(static_cast< int >(result));
48058 {
48059 if (temp2)
48060 delete arg2;
48061 }
48062 return resultobj;
48063 fail:
48064 {
48065 if (temp2)
48066 delete arg2;
48067 }
48068 return NULL;
48069 }
48070
48071
48072 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48073 PyObject *resultobj = 0;
48074 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48075 wxArrayString *arg2 = 0 ;
48076 void *argp1 = 0 ;
48077 int res1 = 0 ;
48078 bool temp2 = false ;
48079 PyObject * obj0 = 0 ;
48080 PyObject * obj1 = 0 ;
48081 char * kwnames[] = {
48082 (char *) "self",(char *) "strings", NULL
48083 };
48084
48085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
48086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48087 if (!SWIG_IsOK(res1)) {
48088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48089 }
48090 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48091 {
48092 if (! PySequence_Check(obj1)) {
48093 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
48094 SWIG_fail;
48095 }
48096 arg2 = new wxArrayString;
48097 temp2 = true;
48098 int i, len=PySequence_Length(obj1);
48099 for (i=0; i<len; i++) {
48100 PyObject* item = PySequence_GetItem(obj1, i);
48101 wxString* s = wxString_in_helper(item);
48102 if (PyErr_Occurred()) SWIG_fail;
48103 arg2->Add(*s);
48104 delete s;
48105 Py_DECREF(item);
48106 }
48107 }
48108 {
48109 PyThreadState* __tstate = wxPyBeginAllowThreads();
48110 (arg1)->Append((wxArrayString const &)*arg2);
48111 wxPyEndAllowThreads(__tstate);
48112 if (PyErr_Occurred()) SWIG_fail;
48113 }
48114 resultobj = SWIG_Py_Void();
48115 {
48116 if (temp2) delete arg2;
48117 }
48118 return resultobj;
48119 fail:
48120 {
48121 if (temp2) delete arg2;
48122 }
48123 return NULL;
48124 }
48125
48126
48127 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48128 PyObject *resultobj = 0;
48129 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48130 wxString *arg2 = 0 ;
48131 int arg3 ;
48132 PyObject *arg4 = (PyObject *) NULL ;
48133 int result;
48134 void *argp1 = 0 ;
48135 int res1 = 0 ;
48136 bool temp2 = false ;
48137 int val3 ;
48138 int ecode3 = 0 ;
48139 PyObject * obj0 = 0 ;
48140 PyObject * obj1 = 0 ;
48141 PyObject * obj2 = 0 ;
48142 PyObject * obj3 = 0 ;
48143 char * kwnames[] = {
48144 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
48145 };
48146
48147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48149 if (!SWIG_IsOK(res1)) {
48150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48151 }
48152 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48153 {
48154 arg2 = wxString_in_helper(obj1);
48155 if (arg2 == NULL) SWIG_fail;
48156 temp2 = true;
48157 }
48158 ecode3 = SWIG_AsVal_int(obj2, &val3);
48159 if (!SWIG_IsOK(ecode3)) {
48160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
48161 }
48162 arg3 = static_cast< int >(val3);
48163 if (obj3) {
48164 arg4 = obj3;
48165 }
48166 {
48167 PyThreadState* __tstate = wxPyBeginAllowThreads();
48168 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
48169 wxPyEndAllowThreads(__tstate);
48170 if (PyErr_Occurred()) SWIG_fail;
48171 }
48172 resultobj = SWIG_From_int(static_cast< int >(result));
48173 {
48174 if (temp2)
48175 delete arg2;
48176 }
48177 return resultobj;
48178 fail:
48179 {
48180 if (temp2)
48181 delete arg2;
48182 }
48183 return NULL;
48184 }
48185
48186
48187 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48188 PyObject *resultobj = 0;
48189 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48190 void *argp1 = 0 ;
48191 int res1 = 0 ;
48192 PyObject *swig_obj[1] ;
48193
48194 if (!args) SWIG_fail;
48195 swig_obj[0] = args;
48196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48197 if (!SWIG_IsOK(res1)) {
48198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48199 }
48200 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48201 {
48202 PyThreadState* __tstate = wxPyBeginAllowThreads();
48203 (arg1)->Clear();
48204 wxPyEndAllowThreads(__tstate);
48205 if (PyErr_Occurred()) SWIG_fail;
48206 }
48207 resultobj = SWIG_Py_Void();
48208 return resultobj;
48209 fail:
48210 return NULL;
48211 }
48212
48213
48214 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48215 PyObject *resultobj = 0;
48216 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48217 int arg2 ;
48218 void *argp1 = 0 ;
48219 int res1 = 0 ;
48220 int val2 ;
48221 int ecode2 = 0 ;
48222 PyObject * obj0 = 0 ;
48223 PyObject * obj1 = 0 ;
48224 char * kwnames[] = {
48225 (char *) "self",(char *) "n", NULL
48226 };
48227
48228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
48229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48230 if (!SWIG_IsOK(res1)) {
48231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48232 }
48233 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48234 ecode2 = SWIG_AsVal_int(obj1, &val2);
48235 if (!SWIG_IsOK(ecode2)) {
48236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
48237 }
48238 arg2 = static_cast< int >(val2);
48239 {
48240 PyThreadState* __tstate = wxPyBeginAllowThreads();
48241 (arg1)->Delete(arg2);
48242 wxPyEndAllowThreads(__tstate);
48243 if (PyErr_Occurred()) SWIG_fail;
48244 }
48245 resultobj = SWIG_Py_Void();
48246 return resultobj;
48247 fail:
48248 return NULL;
48249 }
48250
48251
48252 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48253 PyObject *resultobj = 0;
48254 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48255 int arg2 ;
48256 PyObject *result = 0 ;
48257 void *argp1 = 0 ;
48258 int res1 = 0 ;
48259 int val2 ;
48260 int ecode2 = 0 ;
48261 PyObject * obj0 = 0 ;
48262 PyObject * obj1 = 0 ;
48263 char * kwnames[] = {
48264 (char *) "self",(char *) "n", NULL
48265 };
48266
48267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
48268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48269 if (!SWIG_IsOK(res1)) {
48270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48271 }
48272 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48273 ecode2 = SWIG_AsVal_int(obj1, &val2);
48274 if (!SWIG_IsOK(ecode2)) {
48275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
48276 }
48277 arg2 = static_cast< int >(val2);
48278 {
48279 PyThreadState* __tstate = wxPyBeginAllowThreads();
48280 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
48281 wxPyEndAllowThreads(__tstate);
48282 if (PyErr_Occurred()) SWIG_fail;
48283 }
48284 resultobj = result;
48285 return resultobj;
48286 fail:
48287 return NULL;
48288 }
48289
48290
48291 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48292 PyObject *resultobj = 0;
48293 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48294 int arg2 ;
48295 PyObject *arg3 = (PyObject *) 0 ;
48296 void *argp1 = 0 ;
48297 int res1 = 0 ;
48298 int val2 ;
48299 int ecode2 = 0 ;
48300 PyObject * obj0 = 0 ;
48301 PyObject * obj1 = 0 ;
48302 PyObject * obj2 = 0 ;
48303 char * kwnames[] = {
48304 (char *) "self",(char *) "n",(char *) "clientData", NULL
48305 };
48306
48307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48309 if (!SWIG_IsOK(res1)) {
48310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48311 }
48312 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48313 ecode2 = SWIG_AsVal_int(obj1, &val2);
48314 if (!SWIG_IsOK(ecode2)) {
48315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
48316 }
48317 arg2 = static_cast< int >(val2);
48318 arg3 = obj2;
48319 {
48320 PyThreadState* __tstate = wxPyBeginAllowThreads();
48321 wxItemContainer_SetClientData(arg1,arg2,arg3);
48322 wxPyEndAllowThreads(__tstate);
48323 if (PyErr_Occurred()) SWIG_fail;
48324 }
48325 resultobj = SWIG_Py_Void();
48326 return resultobj;
48327 fail:
48328 return NULL;
48329 }
48330
48331
48332 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48333 PyObject *resultobj = 0;
48334 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48335 int result;
48336 void *argp1 = 0 ;
48337 int res1 = 0 ;
48338 PyObject *swig_obj[1] ;
48339
48340 if (!args) SWIG_fail;
48341 swig_obj[0] = args;
48342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48343 if (!SWIG_IsOK(res1)) {
48344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48345 }
48346 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48347 {
48348 PyThreadState* __tstate = wxPyBeginAllowThreads();
48349 result = (int)((wxItemContainer const *)arg1)->GetCount();
48350 wxPyEndAllowThreads(__tstate);
48351 if (PyErr_Occurred()) SWIG_fail;
48352 }
48353 resultobj = SWIG_From_int(static_cast< int >(result));
48354 return resultobj;
48355 fail:
48356 return NULL;
48357 }
48358
48359
48360 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48361 PyObject *resultobj = 0;
48362 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48363 bool result;
48364 void *argp1 = 0 ;
48365 int res1 = 0 ;
48366 PyObject *swig_obj[1] ;
48367
48368 if (!args) SWIG_fail;
48369 swig_obj[0] = args;
48370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48371 if (!SWIG_IsOK(res1)) {
48372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48373 }
48374 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48375 {
48376 PyThreadState* __tstate = wxPyBeginAllowThreads();
48377 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48378 wxPyEndAllowThreads(__tstate);
48379 if (PyErr_Occurred()) SWIG_fail;
48380 }
48381 {
48382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48383 }
48384 return resultobj;
48385 fail:
48386 return NULL;
48387 }
48388
48389
48390 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48391 PyObject *resultobj = 0;
48392 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48393 int arg2 ;
48394 wxString result;
48395 void *argp1 = 0 ;
48396 int res1 = 0 ;
48397 int val2 ;
48398 int ecode2 = 0 ;
48399 PyObject * obj0 = 0 ;
48400 PyObject * obj1 = 0 ;
48401 char * kwnames[] = {
48402 (char *) "self",(char *) "n", NULL
48403 };
48404
48405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48407 if (!SWIG_IsOK(res1)) {
48408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48409 }
48410 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48411 ecode2 = SWIG_AsVal_int(obj1, &val2);
48412 if (!SWIG_IsOK(ecode2)) {
48413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
48414 }
48415 arg2 = static_cast< int >(val2);
48416 {
48417 PyThreadState* __tstate = wxPyBeginAllowThreads();
48418 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48419 wxPyEndAllowThreads(__tstate);
48420 if (PyErr_Occurred()) SWIG_fail;
48421 }
48422 {
48423 #if wxUSE_UNICODE
48424 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48425 #else
48426 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48427 #endif
48428 }
48429 return resultobj;
48430 fail:
48431 return NULL;
48432 }
48433
48434
48435 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48436 PyObject *resultobj = 0;
48437 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48438 wxArrayString result;
48439 void *argp1 = 0 ;
48440 int res1 = 0 ;
48441 PyObject *swig_obj[1] ;
48442
48443 if (!args) SWIG_fail;
48444 swig_obj[0] = args;
48445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48446 if (!SWIG_IsOK(res1)) {
48447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48448 }
48449 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48450 {
48451 PyThreadState* __tstate = wxPyBeginAllowThreads();
48452 result = ((wxItemContainer const *)arg1)->GetStrings();
48453 wxPyEndAllowThreads(__tstate);
48454 if (PyErr_Occurred()) SWIG_fail;
48455 }
48456 {
48457 resultobj = wxArrayString2PyList_helper(result);
48458 }
48459 return resultobj;
48460 fail:
48461 return NULL;
48462 }
48463
48464
48465 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48466 PyObject *resultobj = 0;
48467 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48468 int arg2 ;
48469 wxString *arg3 = 0 ;
48470 void *argp1 = 0 ;
48471 int res1 = 0 ;
48472 int val2 ;
48473 int ecode2 = 0 ;
48474 bool temp3 = false ;
48475 PyObject * obj0 = 0 ;
48476 PyObject * obj1 = 0 ;
48477 PyObject * obj2 = 0 ;
48478 char * kwnames[] = {
48479 (char *) "self",(char *) "n",(char *) "s", NULL
48480 };
48481
48482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48484 if (!SWIG_IsOK(res1)) {
48485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48486 }
48487 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48488 ecode2 = SWIG_AsVal_int(obj1, &val2);
48489 if (!SWIG_IsOK(ecode2)) {
48490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
48491 }
48492 arg2 = static_cast< int >(val2);
48493 {
48494 arg3 = wxString_in_helper(obj2);
48495 if (arg3 == NULL) SWIG_fail;
48496 temp3 = true;
48497 }
48498 {
48499 PyThreadState* __tstate = wxPyBeginAllowThreads();
48500 (arg1)->SetString(arg2,(wxString const &)*arg3);
48501 wxPyEndAllowThreads(__tstate);
48502 if (PyErr_Occurred()) SWIG_fail;
48503 }
48504 resultobj = SWIG_Py_Void();
48505 {
48506 if (temp3)
48507 delete arg3;
48508 }
48509 return resultobj;
48510 fail:
48511 {
48512 if (temp3)
48513 delete arg3;
48514 }
48515 return NULL;
48516 }
48517
48518
48519 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48520 PyObject *resultobj = 0;
48521 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48522 wxString *arg2 = 0 ;
48523 int result;
48524 void *argp1 = 0 ;
48525 int res1 = 0 ;
48526 bool temp2 = false ;
48527 PyObject * obj0 = 0 ;
48528 PyObject * obj1 = 0 ;
48529 char * kwnames[] = {
48530 (char *) "self",(char *) "s", NULL
48531 };
48532
48533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48535 if (!SWIG_IsOK(res1)) {
48536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48537 }
48538 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48539 {
48540 arg2 = wxString_in_helper(obj1);
48541 if (arg2 == NULL) SWIG_fail;
48542 temp2 = true;
48543 }
48544 {
48545 PyThreadState* __tstate = wxPyBeginAllowThreads();
48546 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48547 wxPyEndAllowThreads(__tstate);
48548 if (PyErr_Occurred()) SWIG_fail;
48549 }
48550 resultobj = SWIG_From_int(static_cast< int >(result));
48551 {
48552 if (temp2)
48553 delete arg2;
48554 }
48555 return resultobj;
48556 fail:
48557 {
48558 if (temp2)
48559 delete arg2;
48560 }
48561 return NULL;
48562 }
48563
48564
48565 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48566 PyObject *resultobj = 0;
48567 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48568 int arg2 ;
48569 void *argp1 = 0 ;
48570 int res1 = 0 ;
48571 int val2 ;
48572 int ecode2 = 0 ;
48573 PyObject * obj0 = 0 ;
48574 PyObject * obj1 = 0 ;
48575 char * kwnames[] = {
48576 (char *) "self",(char *) "n", NULL
48577 };
48578
48579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48581 if (!SWIG_IsOK(res1)) {
48582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48583 }
48584 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48585 ecode2 = SWIG_AsVal_int(obj1, &val2);
48586 if (!SWIG_IsOK(ecode2)) {
48587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48588 }
48589 arg2 = static_cast< int >(val2);
48590 {
48591 PyThreadState* __tstate = wxPyBeginAllowThreads();
48592 (arg1)->SetSelection(arg2);
48593 wxPyEndAllowThreads(__tstate);
48594 if (PyErr_Occurred()) SWIG_fail;
48595 }
48596 resultobj = SWIG_Py_Void();
48597 return resultobj;
48598 fail:
48599 return NULL;
48600 }
48601
48602
48603 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48604 PyObject *resultobj = 0;
48605 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48606 int result;
48607 void *argp1 = 0 ;
48608 int res1 = 0 ;
48609 PyObject *swig_obj[1] ;
48610
48611 if (!args) SWIG_fail;
48612 swig_obj[0] = args;
48613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48614 if (!SWIG_IsOK(res1)) {
48615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48616 }
48617 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48618 {
48619 PyThreadState* __tstate = wxPyBeginAllowThreads();
48620 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48621 wxPyEndAllowThreads(__tstate);
48622 if (PyErr_Occurred()) SWIG_fail;
48623 }
48624 resultobj = SWIG_From_int(static_cast< int >(result));
48625 return resultobj;
48626 fail:
48627 return NULL;
48628 }
48629
48630
48631 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48632 PyObject *resultobj = 0;
48633 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48634 wxString *arg2 = 0 ;
48635 bool result;
48636 void *argp1 = 0 ;
48637 int res1 = 0 ;
48638 bool temp2 = false ;
48639 PyObject * obj0 = 0 ;
48640 PyObject * obj1 = 0 ;
48641 char * kwnames[] = {
48642 (char *) "self",(char *) "s", NULL
48643 };
48644
48645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48647 if (!SWIG_IsOK(res1)) {
48648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48649 }
48650 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48651 {
48652 arg2 = wxString_in_helper(obj1);
48653 if (arg2 == NULL) SWIG_fail;
48654 temp2 = true;
48655 }
48656 {
48657 PyThreadState* __tstate = wxPyBeginAllowThreads();
48658 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48659 wxPyEndAllowThreads(__tstate);
48660 if (PyErr_Occurred()) SWIG_fail;
48661 }
48662 {
48663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48664 }
48665 {
48666 if (temp2)
48667 delete arg2;
48668 }
48669 return resultobj;
48670 fail:
48671 {
48672 if (temp2)
48673 delete arg2;
48674 }
48675 return NULL;
48676 }
48677
48678
48679 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48680 PyObject *resultobj = 0;
48681 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48682 wxString result;
48683 void *argp1 = 0 ;
48684 int res1 = 0 ;
48685 PyObject *swig_obj[1] ;
48686
48687 if (!args) SWIG_fail;
48688 swig_obj[0] = args;
48689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48690 if (!SWIG_IsOK(res1)) {
48691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48692 }
48693 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48694 {
48695 PyThreadState* __tstate = wxPyBeginAllowThreads();
48696 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48697 wxPyEndAllowThreads(__tstate);
48698 if (PyErr_Occurred()) SWIG_fail;
48699 }
48700 {
48701 #if wxUSE_UNICODE
48702 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48703 #else
48704 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48705 #endif
48706 }
48707 return resultobj;
48708 fail:
48709 return NULL;
48710 }
48711
48712
48713 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48714 PyObject *resultobj = 0;
48715 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48716 int arg2 ;
48717 void *argp1 = 0 ;
48718 int res1 = 0 ;
48719 int val2 ;
48720 int ecode2 = 0 ;
48721 PyObject * obj0 = 0 ;
48722 PyObject * obj1 = 0 ;
48723 char * kwnames[] = {
48724 (char *) "self",(char *) "n", NULL
48725 };
48726
48727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48729 if (!SWIG_IsOK(res1)) {
48730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48731 }
48732 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48733 ecode2 = SWIG_AsVal_int(obj1, &val2);
48734 if (!SWIG_IsOK(ecode2)) {
48735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48736 }
48737 arg2 = static_cast< int >(val2);
48738 {
48739 PyThreadState* __tstate = wxPyBeginAllowThreads();
48740 (arg1)->Select(arg2);
48741 wxPyEndAllowThreads(__tstate);
48742 if (PyErr_Occurred()) SWIG_fail;
48743 }
48744 resultobj = SWIG_Py_Void();
48745 return resultobj;
48746 fail:
48747 return NULL;
48748 }
48749
48750
48751 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48752 PyObject *obj;
48753 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48754 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48755 return SWIG_Py_Void();
48756 }
48757
48758 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48759 PyObject *obj;
48760 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48761 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48762 return SWIG_Py_Void();
48763 }
48764
48765 SWIGINTERN PyObject *_wrap_new_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48766 PyObject *resultobj = 0;
48767 int arg1 = (int) 0 ;
48768 wxSizerFlags *result = 0 ;
48769 int val1 ;
48770 int ecode1 = 0 ;
48771 PyObject * obj0 = 0 ;
48772 char * kwnames[] = {
48773 (char *) "proportion", NULL
48774 };
48775
48776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_SizerFlags",kwnames,&obj0)) SWIG_fail;
48777 if (obj0) {
48778 ecode1 = SWIG_AsVal_int(obj0, &val1);
48779 if (!SWIG_IsOK(ecode1)) {
48780 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerFlags" "', expected argument " "1"" of type '" "int""'");
48781 }
48782 arg1 = static_cast< int >(val1);
48783 }
48784 {
48785 PyThreadState* __tstate = wxPyBeginAllowThreads();
48786 result = (wxSizerFlags *)new wxSizerFlags(arg1);
48787 wxPyEndAllowThreads(__tstate);
48788 if (PyErr_Occurred()) SWIG_fail;
48789 }
48790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_NEW | 0 );
48791 return resultobj;
48792 fail:
48793 return NULL;
48794 }
48795
48796
48797 SWIGINTERN PyObject *_wrap_delete_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48798 PyObject *resultobj = 0;
48799 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48800 void *argp1 = 0 ;
48801 int res1 = 0 ;
48802 PyObject *swig_obj[1] ;
48803
48804 if (!args) SWIG_fail;
48805 swig_obj[0] = args;
48806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_DISOWN | 0 );
48807 if (!SWIG_IsOK(res1)) {
48808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerFlags" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48809 }
48810 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48811 {
48812 PyThreadState* __tstate = wxPyBeginAllowThreads();
48813 delete arg1;
48814
48815 wxPyEndAllowThreads(__tstate);
48816 if (PyErr_Occurred()) SWIG_fail;
48817 }
48818 resultobj = SWIG_Py_Void();
48819 return resultobj;
48820 fail:
48821 return NULL;
48822 }
48823
48824
48825 SWIGINTERN PyObject *_wrap_SizerFlags_Proportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48826 PyObject *resultobj = 0;
48827 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48828 int arg2 ;
48829 wxSizerFlags *result = 0 ;
48830 void *argp1 = 0 ;
48831 int res1 = 0 ;
48832 int val2 ;
48833 int ecode2 = 0 ;
48834 PyObject * obj0 = 0 ;
48835 PyObject * obj1 = 0 ;
48836 char * kwnames[] = {
48837 (char *) "self",(char *) "proportion", NULL
48838 };
48839
48840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Proportion",kwnames,&obj0,&obj1)) SWIG_fail;
48841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48842 if (!SWIG_IsOK(res1)) {
48843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Proportion" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48844 }
48845 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48846 ecode2 = SWIG_AsVal_int(obj1, &val2);
48847 if (!SWIG_IsOK(ecode2)) {
48848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Proportion" "', expected argument " "2"" of type '" "int""'");
48849 }
48850 arg2 = static_cast< int >(val2);
48851 {
48852 PyThreadState* __tstate = wxPyBeginAllowThreads();
48853 {
48854 wxSizerFlags &_result_ref = (arg1)->Proportion(arg2);
48855 result = (wxSizerFlags *) &_result_ref;
48856 }
48857 wxPyEndAllowThreads(__tstate);
48858 if (PyErr_Occurred()) SWIG_fail;
48859 }
48860 {
48861 resultobj = obj0; Py_INCREF(resultobj);
48862 }
48863 return resultobj;
48864 fail:
48865 return NULL;
48866 }
48867
48868
48869 SWIGINTERN PyObject *_wrap_SizerFlags_Align(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48870 PyObject *resultobj = 0;
48871 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48872 int arg2 ;
48873 wxSizerFlags *result = 0 ;
48874 void *argp1 = 0 ;
48875 int res1 = 0 ;
48876 int val2 ;
48877 int ecode2 = 0 ;
48878 PyObject * obj0 = 0 ;
48879 PyObject * obj1 = 0 ;
48880 char * kwnames[] = {
48881 (char *) "self",(char *) "alignment", NULL
48882 };
48883
48884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Align",kwnames,&obj0,&obj1)) SWIG_fail;
48885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48886 if (!SWIG_IsOK(res1)) {
48887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Align" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48888 }
48889 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48890 ecode2 = SWIG_AsVal_int(obj1, &val2);
48891 if (!SWIG_IsOK(ecode2)) {
48892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Align" "', expected argument " "2"" of type '" "int""'");
48893 }
48894 arg2 = static_cast< int >(val2);
48895 {
48896 PyThreadState* __tstate = wxPyBeginAllowThreads();
48897 {
48898 wxSizerFlags &_result_ref = (arg1)->Align(arg2);
48899 result = (wxSizerFlags *) &_result_ref;
48900 }
48901 wxPyEndAllowThreads(__tstate);
48902 if (PyErr_Occurred()) SWIG_fail;
48903 }
48904 {
48905 resultobj = obj0; Py_INCREF(resultobj);
48906 }
48907 return resultobj;
48908 fail:
48909 return NULL;
48910 }
48911
48912
48913 SWIGINTERN PyObject *_wrap_SizerFlags_Expand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48914 PyObject *resultobj = 0;
48915 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48916 wxSizerFlags *result = 0 ;
48917 void *argp1 = 0 ;
48918 int res1 = 0 ;
48919 PyObject *swig_obj[1] ;
48920
48921 if (!args) SWIG_fail;
48922 swig_obj[0] = args;
48923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48924 if (!SWIG_IsOK(res1)) {
48925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Expand" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48926 }
48927 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48928 {
48929 PyThreadState* __tstate = wxPyBeginAllowThreads();
48930 {
48931 wxSizerFlags &_result_ref = (arg1)->Expand();
48932 result = (wxSizerFlags *) &_result_ref;
48933 }
48934 wxPyEndAllowThreads(__tstate);
48935 if (PyErr_Occurred()) SWIG_fail;
48936 }
48937 {
48938 resultobj = swig_obj[0]; Py_INCREF(resultobj);
48939 }
48940 return resultobj;
48941 fail:
48942 return NULL;
48943 }
48944
48945
48946 SWIGINTERN PyObject *_wrap_SizerFlags_Centre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48947 PyObject *resultobj = 0;
48948 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48949 wxSizerFlags *result = 0 ;
48950 void *argp1 = 0 ;
48951 int res1 = 0 ;
48952 PyObject *swig_obj[1] ;
48953
48954 if (!args) SWIG_fail;
48955 swig_obj[0] = args;
48956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48957 if (!SWIG_IsOK(res1)) {
48958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Centre" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48959 }
48960 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48961 {
48962 PyThreadState* __tstate = wxPyBeginAllowThreads();
48963 {
48964 wxSizerFlags &_result_ref = (arg1)->Centre();
48965 result = (wxSizerFlags *) &_result_ref;
48966 }
48967 wxPyEndAllowThreads(__tstate);
48968 if (PyErr_Occurred()) SWIG_fail;
48969 }
48970 {
48971 resultobj = swig_obj[0]; Py_INCREF(resultobj);
48972 }
48973 return resultobj;
48974 fail:
48975 return NULL;
48976 }
48977
48978
48979 SWIGINTERN PyObject *_wrap_SizerFlags_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48980 PyObject *resultobj = 0;
48981 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48982 wxSizerFlags *result = 0 ;
48983 void *argp1 = 0 ;
48984 int res1 = 0 ;
48985 PyObject *swig_obj[1] ;
48986
48987 if (!args) SWIG_fail;
48988 swig_obj[0] = args;
48989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48990 if (!SWIG_IsOK(res1)) {
48991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Center" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48992 }
48993 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48994 {
48995 PyThreadState* __tstate = wxPyBeginAllowThreads();
48996 {
48997 wxSizerFlags &_result_ref = (arg1)->Center();
48998 result = (wxSizerFlags *) &_result_ref;
48999 }
49000 wxPyEndAllowThreads(__tstate);
49001 if (PyErr_Occurred()) SWIG_fail;
49002 }
49003 {
49004 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49005 }
49006 return resultobj;
49007 fail:
49008 return NULL;
49009 }
49010
49011
49012 SWIGINTERN PyObject *_wrap_SizerFlags_Left(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49013 PyObject *resultobj = 0;
49014 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49015 wxSizerFlags *result = 0 ;
49016 void *argp1 = 0 ;
49017 int res1 = 0 ;
49018 PyObject *swig_obj[1] ;
49019
49020 if (!args) SWIG_fail;
49021 swig_obj[0] = args;
49022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49023 if (!SWIG_IsOK(res1)) {
49024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Left" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49025 }
49026 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49027 {
49028 PyThreadState* __tstate = wxPyBeginAllowThreads();
49029 {
49030 wxSizerFlags &_result_ref = (arg1)->Left();
49031 result = (wxSizerFlags *) &_result_ref;
49032 }
49033 wxPyEndAllowThreads(__tstate);
49034 if (PyErr_Occurred()) SWIG_fail;
49035 }
49036 {
49037 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49038 }
49039 return resultobj;
49040 fail:
49041 return NULL;
49042 }
49043
49044
49045 SWIGINTERN PyObject *_wrap_SizerFlags_Right(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49046 PyObject *resultobj = 0;
49047 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49048 wxSizerFlags *result = 0 ;
49049 void *argp1 = 0 ;
49050 int res1 = 0 ;
49051 PyObject *swig_obj[1] ;
49052
49053 if (!args) SWIG_fail;
49054 swig_obj[0] = args;
49055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49056 if (!SWIG_IsOK(res1)) {
49057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Right" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49058 }
49059 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49060 {
49061 PyThreadState* __tstate = wxPyBeginAllowThreads();
49062 {
49063 wxSizerFlags &_result_ref = (arg1)->Right();
49064 result = (wxSizerFlags *) &_result_ref;
49065 }
49066 wxPyEndAllowThreads(__tstate);
49067 if (PyErr_Occurred()) SWIG_fail;
49068 }
49069 {
49070 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49071 }
49072 return resultobj;
49073 fail:
49074 return NULL;
49075 }
49076
49077
49078 SWIGINTERN PyObject *_wrap_SizerFlags_Top(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49079 PyObject *resultobj = 0;
49080 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49081 wxSizerFlags *result = 0 ;
49082 void *argp1 = 0 ;
49083 int res1 = 0 ;
49084 PyObject *swig_obj[1] ;
49085
49086 if (!args) SWIG_fail;
49087 swig_obj[0] = args;
49088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49089 if (!SWIG_IsOK(res1)) {
49090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Top" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49091 }
49092 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49093 {
49094 PyThreadState* __tstate = wxPyBeginAllowThreads();
49095 {
49096 wxSizerFlags &_result_ref = (arg1)->Top();
49097 result = (wxSizerFlags *) &_result_ref;
49098 }
49099 wxPyEndAllowThreads(__tstate);
49100 if (PyErr_Occurred()) SWIG_fail;
49101 }
49102 {
49103 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49104 }
49105 return resultobj;
49106 fail:
49107 return NULL;
49108 }
49109
49110
49111 SWIGINTERN PyObject *_wrap_SizerFlags_Bottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49112 PyObject *resultobj = 0;
49113 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49114 wxSizerFlags *result = 0 ;
49115 void *argp1 = 0 ;
49116 int res1 = 0 ;
49117 PyObject *swig_obj[1] ;
49118
49119 if (!args) SWIG_fail;
49120 swig_obj[0] = args;
49121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49122 if (!SWIG_IsOK(res1)) {
49123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Bottom" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49124 }
49125 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49126 {
49127 PyThreadState* __tstate = wxPyBeginAllowThreads();
49128 {
49129 wxSizerFlags &_result_ref = (arg1)->Bottom();
49130 result = (wxSizerFlags *) &_result_ref;
49131 }
49132 wxPyEndAllowThreads(__tstate);
49133 if (PyErr_Occurred()) SWIG_fail;
49134 }
49135 {
49136 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49137 }
49138 return resultobj;
49139 fail:
49140 return NULL;
49141 }
49142
49143
49144 SWIGINTERN PyObject *_wrap_SizerFlags_Shaped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49145 PyObject *resultobj = 0;
49146 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49147 wxSizerFlags *result = 0 ;
49148 void *argp1 = 0 ;
49149 int res1 = 0 ;
49150 PyObject *swig_obj[1] ;
49151
49152 if (!args) SWIG_fail;
49153 swig_obj[0] = args;
49154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49155 if (!SWIG_IsOK(res1)) {
49156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Shaped" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49157 }
49158 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49159 {
49160 PyThreadState* __tstate = wxPyBeginAllowThreads();
49161 {
49162 wxSizerFlags &_result_ref = (arg1)->Shaped();
49163 result = (wxSizerFlags *) &_result_ref;
49164 }
49165 wxPyEndAllowThreads(__tstate);
49166 if (PyErr_Occurred()) SWIG_fail;
49167 }
49168 {
49169 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49170 }
49171 return resultobj;
49172 fail:
49173 return NULL;
49174 }
49175
49176
49177 SWIGINTERN PyObject *_wrap_SizerFlags_FixedMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49178 PyObject *resultobj = 0;
49179 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49180 wxSizerFlags *result = 0 ;
49181 void *argp1 = 0 ;
49182 int res1 = 0 ;
49183 PyObject *swig_obj[1] ;
49184
49185 if (!args) SWIG_fail;
49186 swig_obj[0] = args;
49187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49188 if (!SWIG_IsOK(res1)) {
49189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_FixedMinSize" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49190 }
49191 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49192 {
49193 PyThreadState* __tstate = wxPyBeginAllowThreads();
49194 {
49195 wxSizerFlags &_result_ref = (arg1)->FixedMinSize();
49196 result = (wxSizerFlags *) &_result_ref;
49197 }
49198 wxPyEndAllowThreads(__tstate);
49199 if (PyErr_Occurred()) SWIG_fail;
49200 }
49201 {
49202 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49203 }
49204 return resultobj;
49205 fail:
49206 return NULL;
49207 }
49208
49209
49210 SWIGINTERN PyObject *_wrap_SizerFlags_Border(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49211 PyObject *resultobj = 0;
49212 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49213 int arg2 = (int) wxALL ;
49214 int arg3 = (int) -1 ;
49215 wxSizerFlags *result = 0 ;
49216 void *argp1 = 0 ;
49217 int res1 = 0 ;
49218 int val2 ;
49219 int ecode2 = 0 ;
49220 int val3 ;
49221 int ecode3 = 0 ;
49222 PyObject * obj0 = 0 ;
49223 PyObject * obj1 = 0 ;
49224 PyObject * obj2 = 0 ;
49225 char * kwnames[] = {
49226 (char *) "self",(char *) "direction",(char *) "borderInPixels", NULL
49227 };
49228
49229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:SizerFlags_Border",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49231 if (!SWIG_IsOK(res1)) {
49232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Border" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49233 }
49234 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49235 if (obj1) {
49236 ecode2 = SWIG_AsVal_int(obj1, &val2);
49237 if (!SWIG_IsOK(ecode2)) {
49238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Border" "', expected argument " "2"" of type '" "int""'");
49239 }
49240 arg2 = static_cast< int >(val2);
49241 }
49242 if (obj2) {
49243 ecode3 = SWIG_AsVal_int(obj2, &val3);
49244 if (!SWIG_IsOK(ecode3)) {
49245 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerFlags_Border" "', expected argument " "3"" of type '" "int""'");
49246 }
49247 arg3 = static_cast< int >(val3);
49248 }
49249 {
49250 PyThreadState* __tstate = wxPyBeginAllowThreads();
49251 {
49252 wxSizerFlags &_result_ref = wxSizerFlags_Border(arg1,arg2,arg3);
49253 result = (wxSizerFlags *) &_result_ref;
49254 }
49255 wxPyEndAllowThreads(__tstate);
49256 if (PyErr_Occurred()) SWIG_fail;
49257 }
49258 {
49259 resultobj = obj0; Py_INCREF(resultobj);
49260 }
49261 return resultobj;
49262 fail:
49263 return NULL;
49264 }
49265
49266
49267 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49268 PyObject *resultobj = 0;
49269 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49270 int arg2 = (int) wxALL ;
49271 wxSizerFlags *result = 0 ;
49272 void *argp1 = 0 ;
49273 int res1 = 0 ;
49274 int val2 ;
49275 int ecode2 = 0 ;
49276 PyObject * obj0 = 0 ;
49277 PyObject * obj1 = 0 ;
49278 char * kwnames[] = {
49279 (char *) "self",(char *) "direction", NULL
49280 };
49281
49282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_DoubleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49284 if (!SWIG_IsOK(res1)) {
49285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49286 }
49287 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49288 if (obj1) {
49289 ecode2 = SWIG_AsVal_int(obj1, &val2);
49290 if (!SWIG_IsOK(ecode2)) {
49291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "2"" of type '" "int""'");
49292 }
49293 arg2 = static_cast< int >(val2);
49294 }
49295 {
49296 PyThreadState* __tstate = wxPyBeginAllowThreads();
49297 {
49298 wxSizerFlags &_result_ref = (arg1)->DoubleBorder(arg2);
49299 result = (wxSizerFlags *) &_result_ref;
49300 }
49301 wxPyEndAllowThreads(__tstate);
49302 if (PyErr_Occurred()) SWIG_fail;
49303 }
49304 {
49305 resultobj = obj0; Py_INCREF(resultobj);
49306 }
49307 return resultobj;
49308 fail:
49309 return NULL;
49310 }
49311
49312
49313 SWIGINTERN PyObject *_wrap_SizerFlags_TripleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49314 PyObject *resultobj = 0;
49315 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49316 int arg2 = (int) wxALL ;
49317 wxSizerFlags *result = 0 ;
49318 void *argp1 = 0 ;
49319 int res1 = 0 ;
49320 int val2 ;
49321 int ecode2 = 0 ;
49322 PyObject * obj0 = 0 ;
49323 PyObject * obj1 = 0 ;
49324 char * kwnames[] = {
49325 (char *) "self",(char *) "direction", NULL
49326 };
49327
49328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_TripleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49330 if (!SWIG_IsOK(res1)) {
49331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_TripleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49332 }
49333 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49334 if (obj1) {
49335 ecode2 = SWIG_AsVal_int(obj1, &val2);
49336 if (!SWIG_IsOK(ecode2)) {
49337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_TripleBorder" "', expected argument " "2"" of type '" "int""'");
49338 }
49339 arg2 = static_cast< int >(val2);
49340 }
49341 {
49342 PyThreadState* __tstate = wxPyBeginAllowThreads();
49343 {
49344 wxSizerFlags &_result_ref = (arg1)->TripleBorder(arg2);
49345 result = (wxSizerFlags *) &_result_ref;
49346 }
49347 wxPyEndAllowThreads(__tstate);
49348 if (PyErr_Occurred()) SWIG_fail;
49349 }
49350 {
49351 resultobj = obj0; Py_INCREF(resultobj);
49352 }
49353 return resultobj;
49354 fail:
49355 return NULL;
49356 }
49357
49358
49359 SWIGINTERN PyObject *_wrap_SizerFlags_HorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49360 PyObject *resultobj = 0;
49361 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49362 wxSizerFlags *result = 0 ;
49363 void *argp1 = 0 ;
49364 int res1 = 0 ;
49365 PyObject *swig_obj[1] ;
49366
49367 if (!args) SWIG_fail;
49368 swig_obj[0] = args;
49369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49370 if (!SWIG_IsOK(res1)) {
49371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_HorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49372 }
49373 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49374 {
49375 PyThreadState* __tstate = wxPyBeginAllowThreads();
49376 {
49377 wxSizerFlags &_result_ref = (arg1)->HorzBorder();
49378 result = (wxSizerFlags *) &_result_ref;
49379 }
49380 wxPyEndAllowThreads(__tstate);
49381 if (PyErr_Occurred()) SWIG_fail;
49382 }
49383 {
49384 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49385 }
49386 return resultobj;
49387 fail:
49388 return NULL;
49389 }
49390
49391
49392 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleHorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49393 PyObject *resultobj = 0;
49394 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49395 wxSizerFlags *result = 0 ;
49396 void *argp1 = 0 ;
49397 int res1 = 0 ;
49398 PyObject *swig_obj[1] ;
49399
49400 if (!args) SWIG_fail;
49401 swig_obj[0] = args;
49402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49403 if (!SWIG_IsOK(res1)) {
49404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleHorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49405 }
49406 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49407 {
49408 PyThreadState* __tstate = wxPyBeginAllowThreads();
49409 {
49410 wxSizerFlags &_result_ref = (arg1)->DoubleHorzBorder();
49411 result = (wxSizerFlags *) &_result_ref;
49412 }
49413 wxPyEndAllowThreads(__tstate);
49414 if (PyErr_Occurred()) SWIG_fail;
49415 }
49416 {
49417 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49418 }
49419 return resultobj;
49420 fail:
49421 return NULL;
49422 }
49423
49424
49425 SWIGINTERN PyObject *_wrap_SizerFlags_GetDefaultBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49426 PyObject *resultobj = 0;
49427 int result;
49428
49429 if (!SWIG_Python_UnpackTuple(args,"SizerFlags_GetDefaultBorder",0,0,0)) SWIG_fail;
49430 {
49431 PyThreadState* __tstate = wxPyBeginAllowThreads();
49432 result = (int)wxSizerFlags::GetDefaultBorder();
49433 wxPyEndAllowThreads(__tstate);
49434 if (PyErr_Occurred()) SWIG_fail;
49435 }
49436 resultobj = SWIG_From_int(static_cast< int >(result));
49437 return resultobj;
49438 fail:
49439 return NULL;
49440 }
49441
49442
49443 SWIGINTERN PyObject *_wrap_SizerFlags_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49444 PyObject *resultobj = 0;
49445 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49446 int result;
49447 void *argp1 = 0 ;
49448 int res1 = 0 ;
49449 PyObject *swig_obj[1] ;
49450
49451 if (!args) SWIG_fail;
49452 swig_obj[0] = args;
49453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49454 if (!SWIG_IsOK(res1)) {
49455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetProportion" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
49456 }
49457 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49458 {
49459 PyThreadState* __tstate = wxPyBeginAllowThreads();
49460 result = (int)((wxSizerFlags const *)arg1)->GetProportion();
49461 wxPyEndAllowThreads(__tstate);
49462 if (PyErr_Occurred()) SWIG_fail;
49463 }
49464 resultobj = SWIG_From_int(static_cast< int >(result));
49465 return resultobj;
49466 fail:
49467 return NULL;
49468 }
49469
49470
49471 SWIGINTERN PyObject *_wrap_SizerFlags_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49472 PyObject *resultobj = 0;
49473 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49474 int result;
49475 void *argp1 = 0 ;
49476 int res1 = 0 ;
49477 PyObject *swig_obj[1] ;
49478
49479 if (!args) SWIG_fail;
49480 swig_obj[0] = args;
49481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49482 if (!SWIG_IsOK(res1)) {
49483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetFlags" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
49484 }
49485 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49486 {
49487 PyThreadState* __tstate = wxPyBeginAllowThreads();
49488 result = (int)((wxSizerFlags const *)arg1)->GetFlags();
49489 wxPyEndAllowThreads(__tstate);
49490 if (PyErr_Occurred()) SWIG_fail;
49491 }
49492 resultobj = SWIG_From_int(static_cast< int >(result));
49493 return resultobj;
49494 fail:
49495 return NULL;
49496 }
49497
49498
49499 SWIGINTERN PyObject *_wrap_SizerFlags_GetBorderInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49500 PyObject *resultobj = 0;
49501 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49502 int result;
49503 void *argp1 = 0 ;
49504 int res1 = 0 ;
49505 PyObject *swig_obj[1] ;
49506
49507 if (!args) SWIG_fail;
49508 swig_obj[0] = args;
49509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49510 if (!SWIG_IsOK(res1)) {
49511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetBorderInPixels" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
49512 }
49513 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49514 {
49515 PyThreadState* __tstate = wxPyBeginAllowThreads();
49516 result = (int)((wxSizerFlags const *)arg1)->GetBorderInPixels();
49517 wxPyEndAllowThreads(__tstate);
49518 if (PyErr_Occurred()) SWIG_fail;
49519 }
49520 resultobj = SWIG_From_int(static_cast< int >(result));
49521 return resultobj;
49522 fail:
49523 return NULL;
49524 }
49525
49526
49527 SWIGINTERN PyObject *SizerFlags_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49528 PyObject *obj;
49529 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49530 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerFlags, SWIG_NewClientData(obj));
49531 return SWIG_Py_Void();
49532 }
49533
49534 SWIGINTERN PyObject *SizerFlags_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49535 return SWIG_Python_InitShadowInstance(args);
49536 }
49537
49538 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49539 PyObject *resultobj = 0;
49540 wxSizerItem *result = 0 ;
49541
49542 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
49543 {
49544 PyThreadState* __tstate = wxPyBeginAllowThreads();
49545 result = (wxSizerItem *)new wxSizerItem();
49546 wxPyEndAllowThreads(__tstate);
49547 if (PyErr_Occurred()) SWIG_fail;
49548 }
49549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
49550 return resultobj;
49551 fail:
49552 return NULL;
49553 }
49554
49555
49556 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49557 PyObject *resultobj = 0;
49558 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49559 void *argp1 = 0 ;
49560 int res1 = 0 ;
49561 PyObject *swig_obj[1] ;
49562
49563 if (!args) SWIG_fail;
49564 swig_obj[0] = args;
49565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
49566 if (!SWIG_IsOK(res1)) {
49567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49568 }
49569 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49570 {
49571 PyThreadState* __tstate = wxPyBeginAllowThreads();
49572 delete arg1;
49573
49574 wxPyEndAllowThreads(__tstate);
49575 if (PyErr_Occurred()) SWIG_fail;
49576 }
49577 resultobj = SWIG_Py_Void();
49578 return resultobj;
49579 fail:
49580 return NULL;
49581 }
49582
49583
49584 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49585 PyObject *resultobj = 0;
49586 wxWindow *arg1 = (wxWindow *) 0 ;
49587 int arg2 ;
49588 int arg3 ;
49589 int arg4 ;
49590 PyObject *arg5 = (PyObject *) NULL ;
49591 wxSizerItem *result = 0 ;
49592 void *argp1 = 0 ;
49593 int res1 = 0 ;
49594 int val2 ;
49595 int ecode2 = 0 ;
49596 int val3 ;
49597 int ecode3 = 0 ;
49598 int val4 ;
49599 int ecode4 = 0 ;
49600 PyObject * obj0 = 0 ;
49601 PyObject * obj1 = 0 ;
49602 PyObject * obj2 = 0 ;
49603 PyObject * obj3 = 0 ;
49604 PyObject * obj4 = 0 ;
49605 char * kwnames[] = {
49606 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49607 };
49608
49609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
49610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49611 if (!SWIG_IsOK(res1)) {
49612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49613 }
49614 arg1 = reinterpret_cast< wxWindow * >(argp1);
49615 ecode2 = SWIG_AsVal_int(obj1, &val2);
49616 if (!SWIG_IsOK(ecode2)) {
49617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
49618 }
49619 arg2 = static_cast< int >(val2);
49620 ecode3 = SWIG_AsVal_int(obj2, &val3);
49621 if (!SWIG_IsOK(ecode3)) {
49622 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
49623 }
49624 arg3 = static_cast< int >(val3);
49625 ecode4 = SWIG_AsVal_int(obj3, &val4);
49626 if (!SWIG_IsOK(ecode4)) {
49627 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49628 }
49629 arg4 = static_cast< int >(val4);
49630 if (obj4) {
49631 arg5 = obj4;
49632 }
49633 {
49634 PyThreadState* __tstate = wxPyBeginAllowThreads();
49635 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
49636 wxPyEndAllowThreads(__tstate);
49637 if (PyErr_Occurred()) SWIG_fail;
49638 }
49639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
49640 return resultobj;
49641 fail:
49642 return NULL;
49643 }
49644
49645
49646 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49647 PyObject *resultobj = 0;
49648 int arg1 ;
49649 int arg2 ;
49650 int arg3 ;
49651 int arg4 ;
49652 int arg5 ;
49653 PyObject *arg6 = (PyObject *) NULL ;
49654 wxSizerItem *result = 0 ;
49655 int val1 ;
49656 int ecode1 = 0 ;
49657 int val2 ;
49658 int ecode2 = 0 ;
49659 int val3 ;
49660 int ecode3 = 0 ;
49661 int val4 ;
49662 int ecode4 = 0 ;
49663 int val5 ;
49664 int ecode5 = 0 ;
49665 PyObject * obj0 = 0 ;
49666 PyObject * obj1 = 0 ;
49667 PyObject * obj2 = 0 ;
49668 PyObject * obj3 = 0 ;
49669 PyObject * obj4 = 0 ;
49670 PyObject * obj5 = 0 ;
49671 char * kwnames[] = {
49672 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49673 };
49674
49675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49676 ecode1 = SWIG_AsVal_int(obj0, &val1);
49677 if (!SWIG_IsOK(ecode1)) {
49678 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49679 }
49680 arg1 = static_cast< int >(val1);
49681 ecode2 = SWIG_AsVal_int(obj1, &val2);
49682 if (!SWIG_IsOK(ecode2)) {
49683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49684 }
49685 arg2 = static_cast< int >(val2);
49686 ecode3 = SWIG_AsVal_int(obj2, &val3);
49687 if (!SWIG_IsOK(ecode3)) {
49688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
49689 }
49690 arg3 = static_cast< int >(val3);
49691 ecode4 = SWIG_AsVal_int(obj3, &val4);
49692 if (!SWIG_IsOK(ecode4)) {
49693 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
49694 }
49695 arg4 = static_cast< int >(val4);
49696 ecode5 = SWIG_AsVal_int(obj4, &val5);
49697 if (!SWIG_IsOK(ecode5)) {
49698 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49699 }
49700 arg5 = static_cast< int >(val5);
49701 if (obj5) {
49702 arg6 = obj5;
49703 }
49704 {
49705 PyThreadState* __tstate = wxPyBeginAllowThreads();
49706 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
49707 wxPyEndAllowThreads(__tstate);
49708 if (PyErr_Occurred()) SWIG_fail;
49709 }
49710 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
49711 return resultobj;
49712 fail:
49713 return NULL;
49714 }
49715
49716
49717 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49718 PyObject *resultobj = 0;
49719 wxSizer *arg1 = (wxSizer *) 0 ;
49720 int arg2 ;
49721 int arg3 ;
49722 int arg4 ;
49723 PyObject *arg5 = (PyObject *) NULL ;
49724 wxSizerItem *result = 0 ;
49725 int res1 = 0 ;
49726 int val2 ;
49727 int ecode2 = 0 ;
49728 int val3 ;
49729 int ecode3 = 0 ;
49730 int val4 ;
49731 int ecode4 = 0 ;
49732 PyObject * obj0 = 0 ;
49733 PyObject * obj1 = 0 ;
49734 PyObject * obj2 = 0 ;
49735 PyObject * obj3 = 0 ;
49736 PyObject * obj4 = 0 ;
49737 char * kwnames[] = {
49738 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49739 };
49740
49741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
49742 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49743 if (!SWIG_IsOK(res1)) {
49744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49745 }
49746 ecode2 = SWIG_AsVal_int(obj1, &val2);
49747 if (!SWIG_IsOK(ecode2)) {
49748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
49749 }
49750 arg2 = static_cast< int >(val2);
49751 ecode3 = SWIG_AsVal_int(obj2, &val3);
49752 if (!SWIG_IsOK(ecode3)) {
49753 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
49754 }
49755 arg3 = static_cast< int >(val3);
49756 ecode4 = SWIG_AsVal_int(obj3, &val4);
49757 if (!SWIG_IsOK(ecode4)) {
49758 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49759 }
49760 arg4 = static_cast< int >(val4);
49761 if (obj4) {
49762 arg5 = obj4;
49763 }
49764 {
49765 PyThreadState* __tstate = wxPyBeginAllowThreads();
49766 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
49767 wxPyEndAllowThreads(__tstate);
49768 if (PyErr_Occurred()) SWIG_fail;
49769 }
49770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
49771 return resultobj;
49772 fail:
49773 return NULL;
49774 }
49775
49776
49777 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49778 PyObject *resultobj = 0;
49779 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49780 void *argp1 = 0 ;
49781 int res1 = 0 ;
49782 PyObject *swig_obj[1] ;
49783
49784 if (!args) SWIG_fail;
49785 swig_obj[0] = args;
49786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49787 if (!SWIG_IsOK(res1)) {
49788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49789 }
49790 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49791 {
49792 PyThreadState* __tstate = wxPyBeginAllowThreads();
49793 (arg1)->DeleteWindows();
49794 wxPyEndAllowThreads(__tstate);
49795 if (PyErr_Occurred()) SWIG_fail;
49796 }
49797 resultobj = SWIG_Py_Void();
49798 return resultobj;
49799 fail:
49800 return NULL;
49801 }
49802
49803
49804 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49805 PyObject *resultobj = 0;
49806 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49807 void *argp1 = 0 ;
49808 int res1 = 0 ;
49809 PyObject *swig_obj[1] ;
49810
49811 if (!args) SWIG_fail;
49812 swig_obj[0] = args;
49813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49814 if (!SWIG_IsOK(res1)) {
49815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49816 }
49817 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49818 {
49819 PyThreadState* __tstate = wxPyBeginAllowThreads();
49820 (arg1)->DetachSizer();
49821 wxPyEndAllowThreads(__tstate);
49822 if (PyErr_Occurred()) SWIG_fail;
49823 }
49824 resultobj = SWIG_Py_Void();
49825 return resultobj;
49826 fail:
49827 return NULL;
49828 }
49829
49830
49831 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49832 PyObject *resultobj = 0;
49833 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49834 wxSize result;
49835 void *argp1 = 0 ;
49836 int res1 = 0 ;
49837 PyObject *swig_obj[1] ;
49838
49839 if (!args) SWIG_fail;
49840 swig_obj[0] = args;
49841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49842 if (!SWIG_IsOK(res1)) {
49843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49844 }
49845 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49846 {
49847 PyThreadState* __tstate = wxPyBeginAllowThreads();
49848 result = (arg1)->GetSize();
49849 wxPyEndAllowThreads(__tstate);
49850 if (PyErr_Occurred()) SWIG_fail;
49851 }
49852 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49853 return resultobj;
49854 fail:
49855 return NULL;
49856 }
49857
49858
49859 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49860 PyObject *resultobj = 0;
49861 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49862 wxSize result;
49863 void *argp1 = 0 ;
49864 int res1 = 0 ;
49865 PyObject *swig_obj[1] ;
49866
49867 if (!args) SWIG_fail;
49868 swig_obj[0] = args;
49869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49870 if (!SWIG_IsOK(res1)) {
49871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49872 }
49873 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49874 {
49875 PyThreadState* __tstate = wxPyBeginAllowThreads();
49876 result = (arg1)->CalcMin();
49877 wxPyEndAllowThreads(__tstate);
49878 if (PyErr_Occurred()) SWIG_fail;
49879 }
49880 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49881 return resultobj;
49882 fail:
49883 return NULL;
49884 }
49885
49886
49887 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49888 PyObject *resultobj = 0;
49889 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49890 wxPoint *arg2 = 0 ;
49891 wxSize *arg3 = 0 ;
49892 void *argp1 = 0 ;
49893 int res1 = 0 ;
49894 wxPoint temp2 ;
49895 wxSize temp3 ;
49896 PyObject * obj0 = 0 ;
49897 PyObject * obj1 = 0 ;
49898 PyObject * obj2 = 0 ;
49899 char * kwnames[] = {
49900 (char *) "self",(char *) "pos",(char *) "size", NULL
49901 };
49902
49903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49905 if (!SWIG_IsOK(res1)) {
49906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49907 }
49908 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49909 {
49910 arg2 = &temp2;
49911 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
49912 }
49913 {
49914 arg3 = &temp3;
49915 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
49916 }
49917 {
49918 PyThreadState* __tstate = wxPyBeginAllowThreads();
49919 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
49920 wxPyEndAllowThreads(__tstate);
49921 if (PyErr_Occurred()) SWIG_fail;
49922 }
49923 resultobj = SWIG_Py_Void();
49924 return resultobj;
49925 fail:
49926 return NULL;
49927 }
49928
49929
49930 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49931 PyObject *resultobj = 0;
49932 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49933 wxSize result;
49934 void *argp1 = 0 ;
49935 int res1 = 0 ;
49936 PyObject *swig_obj[1] ;
49937
49938 if (!args) SWIG_fail;
49939 swig_obj[0] = args;
49940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49941 if (!SWIG_IsOK(res1)) {
49942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49943 }
49944 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49945 {
49946 PyThreadState* __tstate = wxPyBeginAllowThreads();
49947 result = (arg1)->GetMinSize();
49948 wxPyEndAllowThreads(__tstate);
49949 if (PyErr_Occurred()) SWIG_fail;
49950 }
49951 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49952 return resultobj;
49953 fail:
49954 return NULL;
49955 }
49956
49957
49958 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49959 PyObject *resultobj = 0;
49960 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49961 wxSize result;
49962 void *argp1 = 0 ;
49963 int res1 = 0 ;
49964 PyObject *swig_obj[1] ;
49965
49966 if (!args) SWIG_fail;
49967 swig_obj[0] = args;
49968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49969 if (!SWIG_IsOK(res1)) {
49970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
49971 }
49972 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49973 {
49974 PyThreadState* __tstate = wxPyBeginAllowThreads();
49975 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
49976 wxPyEndAllowThreads(__tstate);
49977 if (PyErr_Occurred()) SWIG_fail;
49978 }
49979 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49980 return resultobj;
49981 fail:
49982 return NULL;
49983 }
49984
49985
49986 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49987 PyObject *resultobj = 0;
49988 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49989 int arg2 ;
49990 int arg3 ;
49991 void *argp1 = 0 ;
49992 int res1 = 0 ;
49993 int val2 ;
49994 int ecode2 = 0 ;
49995 int val3 ;
49996 int ecode3 = 0 ;
49997 PyObject * obj0 = 0 ;
49998 PyObject * obj1 = 0 ;
49999 PyObject * obj2 = 0 ;
50000 char * kwnames[] = {
50001 (char *) "self",(char *) "x",(char *) "y", NULL
50002 };
50003
50004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50006 if (!SWIG_IsOK(res1)) {
50007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50008 }
50009 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50010 ecode2 = SWIG_AsVal_int(obj1, &val2);
50011 if (!SWIG_IsOK(ecode2)) {
50012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
50013 }
50014 arg2 = static_cast< int >(val2);
50015 ecode3 = SWIG_AsVal_int(obj2, &val3);
50016 if (!SWIG_IsOK(ecode3)) {
50017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
50018 }
50019 arg3 = static_cast< int >(val3);
50020 {
50021 PyThreadState* __tstate = wxPyBeginAllowThreads();
50022 (arg1)->SetInitSize(arg2,arg3);
50023 wxPyEndAllowThreads(__tstate);
50024 if (PyErr_Occurred()) SWIG_fail;
50025 }
50026 resultobj = SWIG_Py_Void();
50027 return resultobj;
50028 fail:
50029 return NULL;
50030 }
50031
50032
50033 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50034 PyObject *resultobj = 0;
50035 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50036 int arg2 ;
50037 int arg3 ;
50038 void *argp1 = 0 ;
50039 int res1 = 0 ;
50040 int val2 ;
50041 int ecode2 = 0 ;
50042 int val3 ;
50043 int ecode3 = 0 ;
50044 PyObject * obj0 = 0 ;
50045 PyObject * obj1 = 0 ;
50046 PyObject * obj2 = 0 ;
50047 char * kwnames[] = {
50048 (char *) "self",(char *) "width",(char *) "height", NULL
50049 };
50050
50051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50053 if (!SWIG_IsOK(res1)) {
50054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50055 }
50056 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50057 ecode2 = SWIG_AsVal_int(obj1, &val2);
50058 if (!SWIG_IsOK(ecode2)) {
50059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
50060 }
50061 arg2 = static_cast< int >(val2);
50062 ecode3 = SWIG_AsVal_int(obj2, &val3);
50063 if (!SWIG_IsOK(ecode3)) {
50064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
50065 }
50066 arg3 = static_cast< int >(val3);
50067 {
50068 PyThreadState* __tstate = wxPyBeginAllowThreads();
50069 (arg1)->SetRatio(arg2,arg3);
50070 wxPyEndAllowThreads(__tstate);
50071 if (PyErr_Occurred()) SWIG_fail;
50072 }
50073 resultobj = SWIG_Py_Void();
50074 return resultobj;
50075 fail:
50076 return NULL;
50077 }
50078
50079
50080 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50081 PyObject *resultobj = 0;
50082 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50083 wxSize *arg2 = 0 ;
50084 void *argp1 = 0 ;
50085 int res1 = 0 ;
50086 wxSize temp2 ;
50087 PyObject * obj0 = 0 ;
50088 PyObject * obj1 = 0 ;
50089 char * kwnames[] = {
50090 (char *) "self",(char *) "size", NULL
50091 };
50092
50093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
50094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50095 if (!SWIG_IsOK(res1)) {
50096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50097 }
50098 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50099 {
50100 arg2 = &temp2;
50101 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50102 }
50103 {
50104 PyThreadState* __tstate = wxPyBeginAllowThreads();
50105 (arg1)->SetRatio((wxSize const &)*arg2);
50106 wxPyEndAllowThreads(__tstate);
50107 if (PyErr_Occurred()) SWIG_fail;
50108 }
50109 resultobj = SWIG_Py_Void();
50110 return resultobj;
50111 fail:
50112 return NULL;
50113 }
50114
50115
50116 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50117 PyObject *resultobj = 0;
50118 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50119 float arg2 ;
50120 void *argp1 = 0 ;
50121 int res1 = 0 ;
50122 float val2 ;
50123 int ecode2 = 0 ;
50124 PyObject * obj0 = 0 ;
50125 PyObject * obj1 = 0 ;
50126 char * kwnames[] = {
50127 (char *) "self",(char *) "ratio", NULL
50128 };
50129
50130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
50131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50132 if (!SWIG_IsOK(res1)) {
50133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50134 }
50135 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50136 ecode2 = SWIG_AsVal_float(obj1, &val2);
50137 if (!SWIG_IsOK(ecode2)) {
50138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
50139 }
50140 arg2 = static_cast< float >(val2);
50141 {
50142 PyThreadState* __tstate = wxPyBeginAllowThreads();
50143 (arg1)->SetRatio(arg2);
50144 wxPyEndAllowThreads(__tstate);
50145 if (PyErr_Occurred()) SWIG_fail;
50146 }
50147 resultobj = SWIG_Py_Void();
50148 return resultobj;
50149 fail:
50150 return NULL;
50151 }
50152
50153
50154 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50155 PyObject *resultobj = 0;
50156 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50157 float result;
50158 void *argp1 = 0 ;
50159 int res1 = 0 ;
50160 PyObject *swig_obj[1] ;
50161
50162 if (!args) SWIG_fail;
50163 swig_obj[0] = args;
50164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50165 if (!SWIG_IsOK(res1)) {
50166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50167 }
50168 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50169 {
50170 PyThreadState* __tstate = wxPyBeginAllowThreads();
50171 result = (float)(arg1)->GetRatio();
50172 wxPyEndAllowThreads(__tstate);
50173 if (PyErr_Occurred()) SWIG_fail;
50174 }
50175 resultobj = SWIG_From_float(static_cast< float >(result));
50176 return resultobj;
50177 fail:
50178 return NULL;
50179 }
50180
50181
50182 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50183 PyObject *resultobj = 0;
50184 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50185 wxRect result;
50186 void *argp1 = 0 ;
50187 int res1 = 0 ;
50188 PyObject *swig_obj[1] ;
50189
50190 if (!args) SWIG_fail;
50191 swig_obj[0] = args;
50192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50193 if (!SWIG_IsOK(res1)) {
50194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50195 }
50196 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50197 {
50198 PyThreadState* __tstate = wxPyBeginAllowThreads();
50199 result = (arg1)->GetRect();
50200 wxPyEndAllowThreads(__tstate);
50201 if (PyErr_Occurred()) SWIG_fail;
50202 }
50203 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
50204 return resultobj;
50205 fail:
50206 return NULL;
50207 }
50208
50209
50210 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50211 PyObject *resultobj = 0;
50212 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50213 bool result;
50214 void *argp1 = 0 ;
50215 int res1 = 0 ;
50216 PyObject *swig_obj[1] ;
50217
50218 if (!args) SWIG_fail;
50219 swig_obj[0] = args;
50220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50221 if (!SWIG_IsOK(res1)) {
50222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50223 }
50224 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50225 {
50226 PyThreadState* __tstate = wxPyBeginAllowThreads();
50227 result = (bool)(arg1)->IsWindow();
50228 wxPyEndAllowThreads(__tstate);
50229 if (PyErr_Occurred()) SWIG_fail;
50230 }
50231 {
50232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50233 }
50234 return resultobj;
50235 fail:
50236 return NULL;
50237 }
50238
50239
50240 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50241 PyObject *resultobj = 0;
50242 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50243 bool result;
50244 void *argp1 = 0 ;
50245 int res1 = 0 ;
50246 PyObject *swig_obj[1] ;
50247
50248 if (!args) SWIG_fail;
50249 swig_obj[0] = args;
50250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50251 if (!SWIG_IsOK(res1)) {
50252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50253 }
50254 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50255 {
50256 PyThreadState* __tstate = wxPyBeginAllowThreads();
50257 result = (bool)(arg1)->IsSizer();
50258 wxPyEndAllowThreads(__tstate);
50259 if (PyErr_Occurred()) SWIG_fail;
50260 }
50261 {
50262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50263 }
50264 return resultobj;
50265 fail:
50266 return NULL;
50267 }
50268
50269
50270 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50271 PyObject *resultobj = 0;
50272 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50273 bool result;
50274 void *argp1 = 0 ;
50275 int res1 = 0 ;
50276 PyObject *swig_obj[1] ;
50277
50278 if (!args) SWIG_fail;
50279 swig_obj[0] = args;
50280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50281 if (!SWIG_IsOK(res1)) {
50282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50283 }
50284 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50285 {
50286 PyThreadState* __tstate = wxPyBeginAllowThreads();
50287 result = (bool)(arg1)->IsSpacer();
50288 wxPyEndAllowThreads(__tstate);
50289 if (PyErr_Occurred()) SWIG_fail;
50290 }
50291 {
50292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50293 }
50294 return resultobj;
50295 fail:
50296 return NULL;
50297 }
50298
50299
50300 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50301 PyObject *resultobj = 0;
50302 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50303 int arg2 ;
50304 void *argp1 = 0 ;
50305 int res1 = 0 ;
50306 int val2 ;
50307 int ecode2 = 0 ;
50308 PyObject * obj0 = 0 ;
50309 PyObject * obj1 = 0 ;
50310 char * kwnames[] = {
50311 (char *) "self",(char *) "proportion", NULL
50312 };
50313
50314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
50315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50316 if (!SWIG_IsOK(res1)) {
50317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50318 }
50319 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50320 ecode2 = SWIG_AsVal_int(obj1, &val2);
50321 if (!SWIG_IsOK(ecode2)) {
50322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
50323 }
50324 arg2 = static_cast< int >(val2);
50325 {
50326 PyThreadState* __tstate = wxPyBeginAllowThreads();
50327 (arg1)->SetProportion(arg2);
50328 wxPyEndAllowThreads(__tstate);
50329 if (PyErr_Occurred()) SWIG_fail;
50330 }
50331 resultobj = SWIG_Py_Void();
50332 return resultobj;
50333 fail:
50334 return NULL;
50335 }
50336
50337
50338 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50339 PyObject *resultobj = 0;
50340 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50341 int result;
50342 void *argp1 = 0 ;
50343 int res1 = 0 ;
50344 PyObject *swig_obj[1] ;
50345
50346 if (!args) SWIG_fail;
50347 swig_obj[0] = args;
50348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50349 if (!SWIG_IsOK(res1)) {
50350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50351 }
50352 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50353 {
50354 PyThreadState* __tstate = wxPyBeginAllowThreads();
50355 result = (int)(arg1)->GetProportion();
50356 wxPyEndAllowThreads(__tstate);
50357 if (PyErr_Occurred()) SWIG_fail;
50358 }
50359 resultobj = SWIG_From_int(static_cast< int >(result));
50360 return resultobj;
50361 fail:
50362 return NULL;
50363 }
50364
50365
50366 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50367 PyObject *resultobj = 0;
50368 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50369 int arg2 ;
50370 void *argp1 = 0 ;
50371 int res1 = 0 ;
50372 int val2 ;
50373 int ecode2 = 0 ;
50374 PyObject * obj0 = 0 ;
50375 PyObject * obj1 = 0 ;
50376 char * kwnames[] = {
50377 (char *) "self",(char *) "flag", NULL
50378 };
50379
50380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
50381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50382 if (!SWIG_IsOK(res1)) {
50383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50384 }
50385 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50386 ecode2 = SWIG_AsVal_int(obj1, &val2);
50387 if (!SWIG_IsOK(ecode2)) {
50388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
50389 }
50390 arg2 = static_cast< int >(val2);
50391 {
50392 PyThreadState* __tstate = wxPyBeginAllowThreads();
50393 (arg1)->SetFlag(arg2);
50394 wxPyEndAllowThreads(__tstate);
50395 if (PyErr_Occurred()) SWIG_fail;
50396 }
50397 resultobj = SWIG_Py_Void();
50398 return resultobj;
50399 fail:
50400 return NULL;
50401 }
50402
50403
50404 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50405 PyObject *resultobj = 0;
50406 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50407 int result;
50408 void *argp1 = 0 ;
50409 int res1 = 0 ;
50410 PyObject *swig_obj[1] ;
50411
50412 if (!args) SWIG_fail;
50413 swig_obj[0] = args;
50414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50415 if (!SWIG_IsOK(res1)) {
50416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50417 }
50418 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50419 {
50420 PyThreadState* __tstate = wxPyBeginAllowThreads();
50421 result = (int)(arg1)->GetFlag();
50422 wxPyEndAllowThreads(__tstate);
50423 if (PyErr_Occurred()) SWIG_fail;
50424 }
50425 resultobj = SWIG_From_int(static_cast< int >(result));
50426 return resultobj;
50427 fail:
50428 return NULL;
50429 }
50430
50431
50432 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50433 PyObject *resultobj = 0;
50434 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50435 int arg2 ;
50436 void *argp1 = 0 ;
50437 int res1 = 0 ;
50438 int val2 ;
50439 int ecode2 = 0 ;
50440 PyObject * obj0 = 0 ;
50441 PyObject * obj1 = 0 ;
50442 char * kwnames[] = {
50443 (char *) "self",(char *) "border", NULL
50444 };
50445
50446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
50447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50448 if (!SWIG_IsOK(res1)) {
50449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50450 }
50451 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50452 ecode2 = SWIG_AsVal_int(obj1, &val2);
50453 if (!SWIG_IsOK(ecode2)) {
50454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
50455 }
50456 arg2 = static_cast< int >(val2);
50457 {
50458 PyThreadState* __tstate = wxPyBeginAllowThreads();
50459 (arg1)->SetBorder(arg2);
50460 wxPyEndAllowThreads(__tstate);
50461 if (PyErr_Occurred()) SWIG_fail;
50462 }
50463 resultobj = SWIG_Py_Void();
50464 return resultobj;
50465 fail:
50466 return NULL;
50467 }
50468
50469
50470 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50471 PyObject *resultobj = 0;
50472 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50473 int result;
50474 void *argp1 = 0 ;
50475 int res1 = 0 ;
50476 PyObject *swig_obj[1] ;
50477
50478 if (!args) SWIG_fail;
50479 swig_obj[0] = args;
50480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50481 if (!SWIG_IsOK(res1)) {
50482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50483 }
50484 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50485 {
50486 PyThreadState* __tstate = wxPyBeginAllowThreads();
50487 result = (int)(arg1)->GetBorder();
50488 wxPyEndAllowThreads(__tstate);
50489 if (PyErr_Occurred()) SWIG_fail;
50490 }
50491 resultobj = SWIG_From_int(static_cast< int >(result));
50492 return resultobj;
50493 fail:
50494 return NULL;
50495 }
50496
50497
50498 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50499 PyObject *resultobj = 0;
50500 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50501 wxWindow *result = 0 ;
50502 void *argp1 = 0 ;
50503 int res1 = 0 ;
50504 PyObject *swig_obj[1] ;
50505
50506 if (!args) SWIG_fail;
50507 swig_obj[0] = args;
50508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50509 if (!SWIG_IsOK(res1)) {
50510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50511 }
50512 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50513 {
50514 PyThreadState* __tstate = wxPyBeginAllowThreads();
50515 result = (wxWindow *)(arg1)->GetWindow();
50516 wxPyEndAllowThreads(__tstate);
50517 if (PyErr_Occurred()) SWIG_fail;
50518 }
50519 {
50520 resultobj = wxPyMake_wxObject(result, 0);
50521 }
50522 return resultobj;
50523 fail:
50524 return NULL;
50525 }
50526
50527
50528 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50529 PyObject *resultobj = 0;
50530 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50531 wxWindow *arg2 = (wxWindow *) 0 ;
50532 void *argp1 = 0 ;
50533 int res1 = 0 ;
50534 void *argp2 = 0 ;
50535 int res2 = 0 ;
50536 PyObject * obj0 = 0 ;
50537 PyObject * obj1 = 0 ;
50538 char * kwnames[] = {
50539 (char *) "self",(char *) "window", NULL
50540 };
50541
50542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50544 if (!SWIG_IsOK(res1)) {
50545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50546 }
50547 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50548 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50549 if (!SWIG_IsOK(res2)) {
50550 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50551 }
50552 arg2 = reinterpret_cast< wxWindow * >(argp2);
50553 {
50554 PyThreadState* __tstate = wxPyBeginAllowThreads();
50555 (arg1)->SetWindow(arg2);
50556 wxPyEndAllowThreads(__tstate);
50557 if (PyErr_Occurred()) SWIG_fail;
50558 }
50559 resultobj = SWIG_Py_Void();
50560 return resultobj;
50561 fail:
50562 return NULL;
50563 }
50564
50565
50566 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50567 PyObject *resultobj = 0;
50568 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50569 wxSizer *result = 0 ;
50570 void *argp1 = 0 ;
50571 int res1 = 0 ;
50572 PyObject *swig_obj[1] ;
50573
50574 if (!args) SWIG_fail;
50575 swig_obj[0] = args;
50576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50577 if (!SWIG_IsOK(res1)) {
50578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50579 }
50580 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50581 {
50582 PyThreadState* __tstate = wxPyBeginAllowThreads();
50583 result = (wxSizer *)(arg1)->GetSizer();
50584 wxPyEndAllowThreads(__tstate);
50585 if (PyErr_Occurred()) SWIG_fail;
50586 }
50587 {
50588 resultobj = wxPyMake_wxObject(result, (bool)0);
50589 }
50590 return resultobj;
50591 fail:
50592 return NULL;
50593 }
50594
50595
50596 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50597 PyObject *resultobj = 0;
50598 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50599 wxSizer *arg2 = (wxSizer *) 0 ;
50600 void *argp1 = 0 ;
50601 int res1 = 0 ;
50602 int res2 = 0 ;
50603 PyObject * obj0 = 0 ;
50604 PyObject * obj1 = 0 ;
50605 char * kwnames[] = {
50606 (char *) "self",(char *) "sizer", NULL
50607 };
50608
50609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50611 if (!SWIG_IsOK(res1)) {
50612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50613 }
50614 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50615 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50616 if (!SWIG_IsOK(res2)) {
50617 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50618 }
50619 {
50620 PyThreadState* __tstate = wxPyBeginAllowThreads();
50621 (arg1)->SetSizer(arg2);
50622 wxPyEndAllowThreads(__tstate);
50623 if (PyErr_Occurred()) SWIG_fail;
50624 }
50625 resultobj = SWIG_Py_Void();
50626 return resultobj;
50627 fail:
50628 return NULL;
50629 }
50630
50631
50632 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50633 PyObject *resultobj = 0;
50634 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50635 wxSize result;
50636 void *argp1 = 0 ;
50637 int res1 = 0 ;
50638 PyObject *swig_obj[1] ;
50639
50640 if (!args) SWIG_fail;
50641 swig_obj[0] = args;
50642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50643 if (!SWIG_IsOK(res1)) {
50644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50645 }
50646 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50647 {
50648 PyThreadState* __tstate = wxPyBeginAllowThreads();
50649 result = (arg1)->GetSpacer();
50650 wxPyEndAllowThreads(__tstate);
50651 if (PyErr_Occurred()) SWIG_fail;
50652 }
50653 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50654 return resultobj;
50655 fail:
50656 return NULL;
50657 }
50658
50659
50660 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50661 PyObject *resultobj = 0;
50662 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50663 wxSize *arg2 = 0 ;
50664 void *argp1 = 0 ;
50665 int res1 = 0 ;
50666 wxSize temp2 ;
50667 PyObject * obj0 = 0 ;
50668 PyObject * obj1 = 0 ;
50669 char * kwnames[] = {
50670 (char *) "self",(char *) "size", NULL
50671 };
50672
50673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
50674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50675 if (!SWIG_IsOK(res1)) {
50676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50677 }
50678 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50679 {
50680 arg2 = &temp2;
50681 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50682 }
50683 {
50684 PyThreadState* __tstate = wxPyBeginAllowThreads();
50685 (arg1)->SetSpacer((wxSize const &)*arg2);
50686 wxPyEndAllowThreads(__tstate);
50687 if (PyErr_Occurred()) SWIG_fail;
50688 }
50689 resultobj = SWIG_Py_Void();
50690 return resultobj;
50691 fail:
50692 return NULL;
50693 }
50694
50695
50696 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50697 PyObject *resultobj = 0;
50698 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50699 bool arg2 ;
50700 void *argp1 = 0 ;
50701 int res1 = 0 ;
50702 bool val2 ;
50703 int ecode2 = 0 ;
50704 PyObject * obj0 = 0 ;
50705 PyObject * obj1 = 0 ;
50706 char * kwnames[] = {
50707 (char *) "self",(char *) "show", NULL
50708 };
50709
50710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
50711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50712 if (!SWIG_IsOK(res1)) {
50713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50714 }
50715 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50716 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50717 if (!SWIG_IsOK(ecode2)) {
50718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
50719 }
50720 arg2 = static_cast< bool >(val2);
50721 {
50722 PyThreadState* __tstate = wxPyBeginAllowThreads();
50723 (arg1)->Show(arg2);
50724 wxPyEndAllowThreads(__tstate);
50725 if (PyErr_Occurred()) SWIG_fail;
50726 }
50727 resultobj = SWIG_Py_Void();
50728 return resultobj;
50729 fail:
50730 return NULL;
50731 }
50732
50733
50734 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50735 PyObject *resultobj = 0;
50736 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50737 bool result;
50738 void *argp1 = 0 ;
50739 int res1 = 0 ;
50740 PyObject *swig_obj[1] ;
50741
50742 if (!args) SWIG_fail;
50743 swig_obj[0] = args;
50744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50745 if (!SWIG_IsOK(res1)) {
50746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50747 }
50748 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50749 {
50750 PyThreadState* __tstate = wxPyBeginAllowThreads();
50751 result = (bool)(arg1)->IsShown();
50752 wxPyEndAllowThreads(__tstate);
50753 if (PyErr_Occurred()) SWIG_fail;
50754 }
50755 {
50756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50757 }
50758 return resultobj;
50759 fail:
50760 return NULL;
50761 }
50762
50763
50764 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50765 PyObject *resultobj = 0;
50766 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50767 wxPoint result;
50768 void *argp1 = 0 ;
50769 int res1 = 0 ;
50770 PyObject *swig_obj[1] ;
50771
50772 if (!args) SWIG_fail;
50773 swig_obj[0] = args;
50774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50775 if (!SWIG_IsOK(res1)) {
50776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50777 }
50778 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50779 {
50780 PyThreadState* __tstate = wxPyBeginAllowThreads();
50781 result = (arg1)->GetPosition();
50782 wxPyEndAllowThreads(__tstate);
50783 if (PyErr_Occurred()) SWIG_fail;
50784 }
50785 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50786 return resultobj;
50787 fail:
50788 return NULL;
50789 }
50790
50791
50792 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50793 PyObject *resultobj = 0;
50794 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50795 PyObject *result = 0 ;
50796 void *argp1 = 0 ;
50797 int res1 = 0 ;
50798 PyObject *swig_obj[1] ;
50799
50800 if (!args) SWIG_fail;
50801 swig_obj[0] = args;
50802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50803 if (!SWIG_IsOK(res1)) {
50804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50805 }
50806 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50807 {
50808 PyThreadState* __tstate = wxPyBeginAllowThreads();
50809 result = (PyObject *)wxSizerItem_GetUserData(arg1);
50810 wxPyEndAllowThreads(__tstate);
50811 if (PyErr_Occurred()) SWIG_fail;
50812 }
50813 resultobj = result;
50814 return resultobj;
50815 fail:
50816 return NULL;
50817 }
50818
50819
50820 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50821 PyObject *resultobj = 0;
50822 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50823 PyObject *arg2 = (PyObject *) 0 ;
50824 void *argp1 = 0 ;
50825 int res1 = 0 ;
50826 PyObject * obj0 = 0 ;
50827 PyObject * obj1 = 0 ;
50828 char * kwnames[] = {
50829 (char *) "self",(char *) "userData", NULL
50830 };
50831
50832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
50833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50834 if (!SWIG_IsOK(res1)) {
50835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50836 }
50837 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50838 arg2 = obj1;
50839 {
50840 PyThreadState* __tstate = wxPyBeginAllowThreads();
50841 wxSizerItem_SetUserData(arg1,arg2);
50842 wxPyEndAllowThreads(__tstate);
50843 if (PyErr_Occurred()) SWIG_fail;
50844 }
50845 resultobj = SWIG_Py_Void();
50846 return resultobj;
50847 fail:
50848 return NULL;
50849 }
50850
50851
50852 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50853 PyObject *obj;
50854 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50855 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
50856 return SWIG_Py_Void();
50857 }
50858
50859 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50860 return SWIG_Python_InitShadowInstance(args);
50861 }
50862
50863 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50864 PyObject *resultobj = 0;
50865 wxSizer *arg1 = (wxSizer *) 0 ;
50866 void *argp1 = 0 ;
50867 int res1 = 0 ;
50868 PyObject *swig_obj[1] ;
50869
50870 if (!args) SWIG_fail;
50871 swig_obj[0] = args;
50872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50873 if (!SWIG_IsOK(res1)) {
50874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50875 }
50876 arg1 = reinterpret_cast< wxSizer * >(argp1);
50877 {
50878 PyThreadState* __tstate = wxPyBeginAllowThreads();
50879 delete arg1;
50880
50881 wxPyEndAllowThreads(__tstate);
50882 if (PyErr_Occurred()) SWIG_fail;
50883 }
50884 resultobj = SWIG_Py_Void();
50885 return resultobj;
50886 fail:
50887 return NULL;
50888 }
50889
50890
50891 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50892 PyObject *resultobj = 0;
50893 wxSizer *arg1 = (wxSizer *) 0 ;
50894 PyObject *arg2 = (PyObject *) 0 ;
50895 void *argp1 = 0 ;
50896 int res1 = 0 ;
50897 PyObject * obj0 = 0 ;
50898 PyObject * obj1 = 0 ;
50899 char * kwnames[] = {
50900 (char *) "self",(char *) "_self", NULL
50901 };
50902
50903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
50904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50905 if (!SWIG_IsOK(res1)) {
50906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
50907 }
50908 arg1 = reinterpret_cast< wxSizer * >(argp1);
50909 arg2 = obj1;
50910 {
50911 PyThreadState* __tstate = wxPyBeginAllowThreads();
50912 wxSizer__setOORInfo(arg1,arg2);
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_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50924 PyObject *resultobj = 0;
50925 wxSizer *arg1 = (wxSizer *) 0 ;
50926 PyObject *arg2 = (PyObject *) 0 ;
50927 int arg3 = (int) 0 ;
50928 int arg4 = (int) 0 ;
50929 int arg5 = (int) 0 ;
50930 PyObject *arg6 = (PyObject *) NULL ;
50931 wxSizerItem *result = 0 ;
50932 void *argp1 = 0 ;
50933 int res1 = 0 ;
50934 int val3 ;
50935 int ecode3 = 0 ;
50936 int val4 ;
50937 int ecode4 = 0 ;
50938 int val5 ;
50939 int ecode5 = 0 ;
50940 PyObject * obj0 = 0 ;
50941 PyObject * obj1 = 0 ;
50942 PyObject * obj2 = 0 ;
50943 PyObject * obj3 = 0 ;
50944 PyObject * obj4 = 0 ;
50945 PyObject * obj5 = 0 ;
50946 char * kwnames[] = {
50947 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50948 };
50949
50950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50952 if (!SWIG_IsOK(res1)) {
50953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
50954 }
50955 arg1 = reinterpret_cast< wxSizer * >(argp1);
50956 arg2 = obj1;
50957 if (obj2) {
50958 ecode3 = SWIG_AsVal_int(obj2, &val3);
50959 if (!SWIG_IsOK(ecode3)) {
50960 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
50961 }
50962 arg3 = static_cast< int >(val3);
50963 }
50964 if (obj3) {
50965 ecode4 = SWIG_AsVal_int(obj3, &val4);
50966 if (!SWIG_IsOK(ecode4)) {
50967 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
50968 }
50969 arg4 = static_cast< int >(val4);
50970 }
50971 if (obj4) {
50972 ecode5 = SWIG_AsVal_int(obj4, &val5);
50973 if (!SWIG_IsOK(ecode5)) {
50974 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
50975 }
50976 arg5 = static_cast< int >(val5);
50977 }
50978 if (obj5) {
50979 arg6 = obj5;
50980 }
50981 {
50982 PyThreadState* __tstate = wxPyBeginAllowThreads();
50983 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
50984 wxPyEndAllowThreads(__tstate);
50985 if (PyErr_Occurred()) SWIG_fail;
50986 }
50987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50988 return resultobj;
50989 fail:
50990 return NULL;
50991 }
50992
50993
50994 SWIGINTERN PyObject *_wrap_Sizer_AddF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50995 PyObject *resultobj = 0;
50996 wxSizer *arg1 = (wxSizer *) 0 ;
50997 PyObject *arg2 = (PyObject *) 0 ;
50998 wxSizerFlags *arg3 = 0 ;
50999 wxSizerItem *result = 0 ;
51000 void *argp1 = 0 ;
51001 int res1 = 0 ;
51002 void *argp3 = 0 ;
51003 int res3 = 0 ;
51004 PyObject * obj0 = 0 ;
51005 PyObject * obj1 = 0 ;
51006 PyObject * obj2 = 0 ;
51007 char * kwnames[] = {
51008 (char *) "self",(char *) "item",(char *) "flags", NULL
51009 };
51010
51011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_AddF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51013 if (!SWIG_IsOK(res1)) {
51014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddF" "', expected argument " "1"" of type '" "wxSizer *""'");
51015 }
51016 arg1 = reinterpret_cast< wxSizer * >(argp1);
51017 arg2 = obj1;
51018 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
51019 if (!SWIG_IsOK(res3)) {
51020 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51021 }
51022 if (!argp3) {
51023 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51024 }
51025 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51026 {
51027 PyThreadState* __tstate = wxPyBeginAllowThreads();
51028 result = (wxSizerItem *)wxSizer_AddF(arg1,arg2,*arg3);
51029 wxPyEndAllowThreads(__tstate);
51030 if (PyErr_Occurred()) SWIG_fail;
51031 }
51032 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51033 return resultobj;
51034 fail:
51035 return NULL;
51036 }
51037
51038
51039 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51040 PyObject *resultobj = 0;
51041 wxSizer *arg1 = (wxSizer *) 0 ;
51042 int arg2 ;
51043 PyObject *arg3 = (PyObject *) 0 ;
51044 int arg4 = (int) 0 ;
51045 int arg5 = (int) 0 ;
51046 int arg6 = (int) 0 ;
51047 PyObject *arg7 = (PyObject *) NULL ;
51048 wxSizerItem *result = 0 ;
51049 void *argp1 = 0 ;
51050 int res1 = 0 ;
51051 int val2 ;
51052 int ecode2 = 0 ;
51053 int val4 ;
51054 int ecode4 = 0 ;
51055 int val5 ;
51056 int ecode5 = 0 ;
51057 int val6 ;
51058 int ecode6 = 0 ;
51059 PyObject * obj0 = 0 ;
51060 PyObject * obj1 = 0 ;
51061 PyObject * obj2 = 0 ;
51062 PyObject * obj3 = 0 ;
51063 PyObject * obj4 = 0 ;
51064 PyObject * obj5 = 0 ;
51065 PyObject * obj6 = 0 ;
51066 char * kwnames[] = {
51067 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51068 };
51069
51070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51072 if (!SWIG_IsOK(res1)) {
51073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
51074 }
51075 arg1 = reinterpret_cast< wxSizer * >(argp1);
51076 ecode2 = SWIG_AsVal_int(obj1, &val2);
51077 if (!SWIG_IsOK(ecode2)) {
51078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
51079 }
51080 arg2 = static_cast< int >(val2);
51081 arg3 = obj2;
51082 if (obj3) {
51083 ecode4 = SWIG_AsVal_int(obj3, &val4);
51084 if (!SWIG_IsOK(ecode4)) {
51085 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
51086 }
51087 arg4 = static_cast< int >(val4);
51088 }
51089 if (obj4) {
51090 ecode5 = SWIG_AsVal_int(obj4, &val5);
51091 if (!SWIG_IsOK(ecode5)) {
51092 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
51093 }
51094 arg5 = static_cast< int >(val5);
51095 }
51096 if (obj5) {
51097 ecode6 = SWIG_AsVal_int(obj5, &val6);
51098 if (!SWIG_IsOK(ecode6)) {
51099 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
51100 }
51101 arg6 = static_cast< int >(val6);
51102 }
51103 if (obj6) {
51104 arg7 = obj6;
51105 }
51106 {
51107 PyThreadState* __tstate = wxPyBeginAllowThreads();
51108 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
51109 wxPyEndAllowThreads(__tstate);
51110 if (PyErr_Occurred()) SWIG_fail;
51111 }
51112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51113 return resultobj;
51114 fail:
51115 return NULL;
51116 }
51117
51118
51119 SWIGINTERN PyObject *_wrap_Sizer_InsertF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51120 PyObject *resultobj = 0;
51121 wxSizer *arg1 = (wxSizer *) 0 ;
51122 int arg2 ;
51123 PyObject *arg3 = (PyObject *) 0 ;
51124 wxSizerFlags *arg4 = 0 ;
51125 wxSizerItem *result = 0 ;
51126 void *argp1 = 0 ;
51127 int res1 = 0 ;
51128 int val2 ;
51129 int ecode2 = 0 ;
51130 void *argp4 = 0 ;
51131 int res4 = 0 ;
51132 PyObject * obj0 = 0 ;
51133 PyObject * obj1 = 0 ;
51134 PyObject * obj2 = 0 ;
51135 PyObject * obj3 = 0 ;
51136 char * kwnames[] = {
51137 (char *) "self",(char *) "before",(char *) "item",(char *) "flags", NULL
51138 };
51139
51140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Sizer_InsertF",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51142 if (!SWIG_IsOK(res1)) {
51143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertF" "', expected argument " "1"" of type '" "wxSizer *""'");
51144 }
51145 arg1 = reinterpret_cast< wxSizer * >(argp1);
51146 ecode2 = SWIG_AsVal_int(obj1, &val2);
51147 if (!SWIG_IsOK(ecode2)) {
51148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertF" "', expected argument " "2"" of type '" "int""'");
51149 }
51150 arg2 = static_cast< int >(val2);
51151 arg3 = obj2;
51152 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxSizerFlags, 0 );
51153 if (!SWIG_IsOK(res4)) {
51154 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51155 }
51156 if (!argp4) {
51157 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51158 }
51159 arg4 = reinterpret_cast< wxSizerFlags * >(argp4);
51160 {
51161 PyThreadState* __tstate = wxPyBeginAllowThreads();
51162 result = (wxSizerItem *)wxSizer_InsertF(arg1,arg2,arg3,*arg4);
51163 wxPyEndAllowThreads(__tstate);
51164 if (PyErr_Occurred()) SWIG_fail;
51165 }
51166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51167 return resultobj;
51168 fail:
51169 return NULL;
51170 }
51171
51172
51173 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51174 PyObject *resultobj = 0;
51175 wxSizer *arg1 = (wxSizer *) 0 ;
51176 PyObject *arg2 = (PyObject *) 0 ;
51177 int arg3 = (int) 0 ;
51178 int arg4 = (int) 0 ;
51179 int arg5 = (int) 0 ;
51180 PyObject *arg6 = (PyObject *) NULL ;
51181 wxSizerItem *result = 0 ;
51182 void *argp1 = 0 ;
51183 int res1 = 0 ;
51184 int val3 ;
51185 int ecode3 = 0 ;
51186 int val4 ;
51187 int ecode4 = 0 ;
51188 int val5 ;
51189 int ecode5 = 0 ;
51190 PyObject * obj0 = 0 ;
51191 PyObject * obj1 = 0 ;
51192 PyObject * obj2 = 0 ;
51193 PyObject * obj3 = 0 ;
51194 PyObject * obj4 = 0 ;
51195 PyObject * obj5 = 0 ;
51196 char * kwnames[] = {
51197 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51198 };
51199
51200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51202 if (!SWIG_IsOK(res1)) {
51203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
51204 }
51205 arg1 = reinterpret_cast< wxSizer * >(argp1);
51206 arg2 = obj1;
51207 if (obj2) {
51208 ecode3 = SWIG_AsVal_int(obj2, &val3);
51209 if (!SWIG_IsOK(ecode3)) {
51210 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
51211 }
51212 arg3 = static_cast< int >(val3);
51213 }
51214 if (obj3) {
51215 ecode4 = SWIG_AsVal_int(obj3, &val4);
51216 if (!SWIG_IsOK(ecode4)) {
51217 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
51218 }
51219 arg4 = static_cast< int >(val4);
51220 }
51221 if (obj4) {
51222 ecode5 = SWIG_AsVal_int(obj4, &val5);
51223 if (!SWIG_IsOK(ecode5)) {
51224 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
51225 }
51226 arg5 = static_cast< int >(val5);
51227 }
51228 if (obj5) {
51229 arg6 = obj5;
51230 }
51231 {
51232 PyThreadState* __tstate = wxPyBeginAllowThreads();
51233 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
51234 wxPyEndAllowThreads(__tstate);
51235 if (PyErr_Occurred()) SWIG_fail;
51236 }
51237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51238 return resultobj;
51239 fail:
51240 return NULL;
51241 }
51242
51243
51244 SWIGINTERN PyObject *_wrap_Sizer_PrependF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51245 PyObject *resultobj = 0;
51246 wxSizer *arg1 = (wxSizer *) 0 ;
51247 PyObject *arg2 = (PyObject *) 0 ;
51248 wxSizerFlags *arg3 = 0 ;
51249 wxSizerItem *result = 0 ;
51250 void *argp1 = 0 ;
51251 int res1 = 0 ;
51252 void *argp3 = 0 ;
51253 int res3 = 0 ;
51254 PyObject * obj0 = 0 ;
51255 PyObject * obj1 = 0 ;
51256 PyObject * obj2 = 0 ;
51257 char * kwnames[] = {
51258 (char *) "self",(char *) "item",(char *) "flags", NULL
51259 };
51260
51261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_PrependF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51263 if (!SWIG_IsOK(res1)) {
51264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependF" "', expected argument " "1"" of type '" "wxSizer *""'");
51265 }
51266 arg1 = reinterpret_cast< wxSizer * >(argp1);
51267 arg2 = obj1;
51268 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
51269 if (!SWIG_IsOK(res3)) {
51270 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51271 }
51272 if (!argp3) {
51273 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51274 }
51275 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51276 {
51277 PyThreadState* __tstate = wxPyBeginAllowThreads();
51278 result = (wxSizerItem *)wxSizer_PrependF(arg1,arg2,*arg3);
51279 wxPyEndAllowThreads(__tstate);
51280 if (PyErr_Occurred()) SWIG_fail;
51281 }
51282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51283 return resultobj;
51284 fail:
51285 return NULL;
51286 }
51287
51288
51289 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51290 PyObject *resultobj = 0;
51291 wxSizer *arg1 = (wxSizer *) 0 ;
51292 PyObject *arg2 = (PyObject *) 0 ;
51293 bool result;
51294 void *argp1 = 0 ;
51295 int res1 = 0 ;
51296 PyObject * obj0 = 0 ;
51297 PyObject * obj1 = 0 ;
51298 char * kwnames[] = {
51299 (char *) "self",(char *) "item", NULL
51300 };
51301
51302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
51303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51304 if (!SWIG_IsOK(res1)) {
51305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
51306 }
51307 arg1 = reinterpret_cast< wxSizer * >(argp1);
51308 arg2 = obj1;
51309 {
51310 PyThreadState* __tstate = wxPyBeginAllowThreads();
51311 result = (bool)wxSizer_Remove(arg1,arg2);
51312 wxPyEndAllowThreads(__tstate);
51313 if (PyErr_Occurred()) SWIG_fail;
51314 }
51315 {
51316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51317 }
51318 return resultobj;
51319 fail:
51320 return NULL;
51321 }
51322
51323
51324 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51325 PyObject *resultobj = 0;
51326 wxSizer *arg1 = (wxSizer *) 0 ;
51327 PyObject *arg2 = (PyObject *) 0 ;
51328 bool result;
51329 void *argp1 = 0 ;
51330 int res1 = 0 ;
51331 PyObject * obj0 = 0 ;
51332 PyObject * obj1 = 0 ;
51333 char * kwnames[] = {
51334 (char *) "self",(char *) "item", NULL
51335 };
51336
51337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
51338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51339 if (!SWIG_IsOK(res1)) {
51340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
51341 }
51342 arg1 = reinterpret_cast< wxSizer * >(argp1);
51343 arg2 = obj1;
51344 {
51345 PyThreadState* __tstate = wxPyBeginAllowThreads();
51346 result = (bool)wxSizer_Detach(arg1,arg2);
51347 wxPyEndAllowThreads(__tstate);
51348 if (PyErr_Occurred()) SWIG_fail;
51349 }
51350 {
51351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51352 }
51353 return resultobj;
51354 fail:
51355 return NULL;
51356 }
51357
51358
51359 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51360 PyObject *resultobj = 0;
51361 wxSizer *arg1 = (wxSizer *) 0 ;
51362 PyObject *arg2 = (PyObject *) 0 ;
51363 bool arg3 = (bool) false ;
51364 wxSizerItem *result = 0 ;
51365 void *argp1 = 0 ;
51366 int res1 = 0 ;
51367 bool val3 ;
51368 int ecode3 = 0 ;
51369 PyObject * obj0 = 0 ;
51370 PyObject * obj1 = 0 ;
51371 PyObject * obj2 = 0 ;
51372 char * kwnames[] = {
51373 (char *) "self",(char *) "item",(char *) "recursive", NULL
51374 };
51375
51376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Sizer_GetItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51378 if (!SWIG_IsOK(res1)) {
51379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51380 }
51381 arg1 = reinterpret_cast< wxSizer * >(argp1);
51382 arg2 = obj1;
51383 if (obj2) {
51384 ecode3 = SWIG_AsVal_bool(obj2, &val3);
51385 if (!SWIG_IsOK(ecode3)) {
51386 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_GetItem" "', expected argument " "3"" of type '" "bool""'");
51387 }
51388 arg3 = static_cast< bool >(val3);
51389 }
51390 {
51391 PyThreadState* __tstate = wxPyBeginAllowThreads();
51392 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2,arg3);
51393 wxPyEndAllowThreads(__tstate);
51394 if (PyErr_Occurred()) SWIG_fail;
51395 }
51396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51397 return resultobj;
51398 fail:
51399 return NULL;
51400 }
51401
51402
51403 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51404 PyObject *resultobj = 0;
51405 wxSizer *arg1 = (wxSizer *) 0 ;
51406 PyObject *arg2 = (PyObject *) 0 ;
51407 wxSize *arg3 = 0 ;
51408 void *argp1 = 0 ;
51409 int res1 = 0 ;
51410 wxSize temp3 ;
51411 PyObject * obj0 = 0 ;
51412 PyObject * obj1 = 0 ;
51413 PyObject * obj2 = 0 ;
51414 char * kwnames[] = {
51415 (char *) "self",(char *) "item",(char *) "size", NULL
51416 };
51417
51418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51420 if (!SWIG_IsOK(res1)) {
51421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
51422 }
51423 arg1 = reinterpret_cast< wxSizer * >(argp1);
51424 arg2 = obj1;
51425 {
51426 arg3 = &temp3;
51427 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
51428 }
51429 {
51430 PyThreadState* __tstate = wxPyBeginAllowThreads();
51431 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
51432 wxPyEndAllowThreads(__tstate);
51433 if (PyErr_Occurred()) SWIG_fail;
51434 }
51435 resultobj = SWIG_Py_Void();
51436 return resultobj;
51437 fail:
51438 return NULL;
51439 }
51440
51441
51442 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51443 PyObject *resultobj = 0;
51444 wxSizer *arg1 = (wxSizer *) 0 ;
51445 wxWindow *arg2 = (wxWindow *) 0 ;
51446 wxWindow *arg3 = (wxWindow *) 0 ;
51447 bool arg4 = (bool) false ;
51448 bool result;
51449 void *argp1 = 0 ;
51450 int res1 = 0 ;
51451 void *argp2 = 0 ;
51452 int res2 = 0 ;
51453 void *argp3 = 0 ;
51454 int res3 = 0 ;
51455 bool val4 ;
51456 int ecode4 = 0 ;
51457 PyObject * obj0 = 0 ;
51458 PyObject * obj1 = 0 ;
51459 PyObject * obj2 = 0 ;
51460 PyObject * obj3 = 0 ;
51461 char * kwnames[] = {
51462 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
51463 };
51464
51465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51467 if (!SWIG_IsOK(res1)) {
51468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
51469 }
51470 arg1 = reinterpret_cast< wxSizer * >(argp1);
51471 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51472 if (!SWIG_IsOK(res2)) {
51473 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
51474 }
51475 arg2 = reinterpret_cast< wxWindow * >(argp2);
51476 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51477 if (!SWIG_IsOK(res3)) {
51478 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
51479 }
51480 arg3 = reinterpret_cast< wxWindow * >(argp3);
51481 if (obj3) {
51482 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51483 if (!SWIG_IsOK(ecode4)) {
51484 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
51485 }
51486 arg4 = static_cast< bool >(val4);
51487 }
51488 {
51489 PyThreadState* __tstate = wxPyBeginAllowThreads();
51490 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
51491 wxPyEndAllowThreads(__tstate);
51492 if (PyErr_Occurred()) SWIG_fail;
51493 }
51494 {
51495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51496 }
51497 return resultobj;
51498 fail:
51499 return NULL;
51500 }
51501
51502
51503 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51504 PyObject *resultobj = 0;
51505 wxSizer *arg1 = (wxSizer *) 0 ;
51506 wxSizer *arg2 = (wxSizer *) 0 ;
51507 wxSizer *arg3 = (wxSizer *) 0 ;
51508 bool arg4 = (bool) false ;
51509 bool result;
51510 void *argp1 = 0 ;
51511 int res1 = 0 ;
51512 void *argp2 = 0 ;
51513 int res2 = 0 ;
51514 void *argp3 = 0 ;
51515 int res3 = 0 ;
51516 bool val4 ;
51517 int ecode4 = 0 ;
51518 PyObject * obj0 = 0 ;
51519 PyObject * obj1 = 0 ;
51520 PyObject * obj2 = 0 ;
51521 PyObject * obj3 = 0 ;
51522 char * kwnames[] = {
51523 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
51524 };
51525
51526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51528 if (!SWIG_IsOK(res1)) {
51529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51530 }
51531 arg1 = reinterpret_cast< wxSizer * >(argp1);
51532 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51533 if (!SWIG_IsOK(res2)) {
51534 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
51535 }
51536 arg2 = reinterpret_cast< wxSizer * >(argp2);
51537 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
51538 if (!SWIG_IsOK(res3)) {
51539 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
51540 }
51541 arg3 = reinterpret_cast< wxSizer * >(argp3);
51542 if (obj3) {
51543 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51544 if (!SWIG_IsOK(ecode4)) {
51545 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
51546 }
51547 arg4 = static_cast< bool >(val4);
51548 }
51549 {
51550 PyThreadState* __tstate = wxPyBeginAllowThreads();
51551 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
51552 wxPyEndAllowThreads(__tstate);
51553 if (PyErr_Occurred()) SWIG_fail;
51554 }
51555 {
51556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51557 }
51558 return resultobj;
51559 fail:
51560 return NULL;
51561 }
51562
51563
51564 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51565 PyObject *resultobj = 0;
51566 wxSizer *arg1 = (wxSizer *) 0 ;
51567 size_t arg2 ;
51568 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
51569 bool result;
51570 void *argp1 = 0 ;
51571 int res1 = 0 ;
51572 size_t val2 ;
51573 int ecode2 = 0 ;
51574 void *argp3 = 0 ;
51575 int res3 = 0 ;
51576 PyObject * obj0 = 0 ;
51577 PyObject * obj1 = 0 ;
51578 PyObject * obj2 = 0 ;
51579 char * kwnames[] = {
51580 (char *) "self",(char *) "index",(char *) "newitem", NULL
51581 };
51582
51583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51585 if (!SWIG_IsOK(res1)) {
51586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51587 }
51588 arg1 = reinterpret_cast< wxSizer * >(argp1);
51589 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51590 if (!SWIG_IsOK(ecode2)) {
51591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
51592 }
51593 arg2 = static_cast< size_t >(val2);
51594 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51595 if (!SWIG_IsOK(res3)) {
51596 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
51597 }
51598 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
51599 {
51600 PyThreadState* __tstate = wxPyBeginAllowThreads();
51601 result = (bool)(arg1)->Replace(arg2,arg3);
51602 wxPyEndAllowThreads(__tstate);
51603 if (PyErr_Occurred()) SWIG_fail;
51604 }
51605 {
51606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51607 }
51608 return resultobj;
51609 fail:
51610 return NULL;
51611 }
51612
51613
51614 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51615 PyObject *resultobj = 0;
51616 wxSizer *arg1 = (wxSizer *) 0 ;
51617 wxWindow *arg2 = (wxWindow *) 0 ;
51618 void *argp1 = 0 ;
51619 int res1 = 0 ;
51620 void *argp2 = 0 ;
51621 int res2 = 0 ;
51622 PyObject * obj0 = 0 ;
51623 PyObject * obj1 = 0 ;
51624 char * kwnames[] = {
51625 (char *) "self",(char *) "window", NULL
51626 };
51627
51628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
51629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51630 if (!SWIG_IsOK(res1)) {
51631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
51632 }
51633 arg1 = reinterpret_cast< wxSizer * >(argp1);
51634 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51635 if (!SWIG_IsOK(res2)) {
51636 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
51637 }
51638 arg2 = reinterpret_cast< wxWindow * >(argp2);
51639 {
51640 PyThreadState* __tstate = wxPyBeginAllowThreads();
51641 (arg1)->SetContainingWindow(arg2);
51642 wxPyEndAllowThreads(__tstate);
51643 if (PyErr_Occurred()) SWIG_fail;
51644 }
51645 resultobj = SWIG_Py_Void();
51646 return resultobj;
51647 fail:
51648 return NULL;
51649 }
51650
51651
51652 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51653 PyObject *resultobj = 0;
51654 wxSizer *arg1 = (wxSizer *) 0 ;
51655 wxWindow *result = 0 ;
51656 void *argp1 = 0 ;
51657 int res1 = 0 ;
51658 PyObject *swig_obj[1] ;
51659
51660 if (!args) SWIG_fail;
51661 swig_obj[0] = args;
51662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51663 if (!SWIG_IsOK(res1)) {
51664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
51665 }
51666 arg1 = reinterpret_cast< wxSizer * >(argp1);
51667 {
51668 PyThreadState* __tstate = wxPyBeginAllowThreads();
51669 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
51670 wxPyEndAllowThreads(__tstate);
51671 if (PyErr_Occurred()) SWIG_fail;
51672 }
51673 {
51674 resultobj = wxPyMake_wxObject(result, 0);
51675 }
51676 return resultobj;
51677 fail:
51678 return NULL;
51679 }
51680
51681
51682 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51683 PyObject *resultobj = 0;
51684 wxSizer *arg1 = (wxSizer *) 0 ;
51685 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
51686 wxSizerItem *result = 0 ;
51687 void *argp1 = 0 ;
51688 int res1 = 0 ;
51689 int res2 = 0 ;
51690 PyObject * obj0 = 0 ;
51691 PyObject * obj1 = 0 ;
51692 char * kwnames[] = {
51693 (char *) "self",(char *) "item", NULL
51694 };
51695
51696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51698 if (!SWIG_IsOK(res1)) {
51699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51700 }
51701 arg1 = reinterpret_cast< wxSizer * >(argp1);
51702 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
51703 if (!SWIG_IsOK(res2)) {
51704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
51705 }
51706 {
51707 PyThreadState* __tstate = wxPyBeginAllowThreads();
51708 result = (wxSizerItem *)(arg1)->Add(arg2);
51709 wxPyEndAllowThreads(__tstate);
51710 if (PyErr_Occurred()) SWIG_fail;
51711 }
51712 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51713 return resultobj;
51714 fail:
51715 return NULL;
51716 }
51717
51718
51719 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51720 PyObject *resultobj = 0;
51721 wxSizer *arg1 = (wxSizer *) 0 ;
51722 size_t arg2 ;
51723 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
51724 wxSizerItem *result = 0 ;
51725 void *argp1 = 0 ;
51726 int res1 = 0 ;
51727 size_t val2 ;
51728 int ecode2 = 0 ;
51729 int res3 = 0 ;
51730 PyObject * obj0 = 0 ;
51731 PyObject * obj1 = 0 ;
51732 PyObject * obj2 = 0 ;
51733 char * kwnames[] = {
51734 (char *) "self",(char *) "index",(char *) "item", NULL
51735 };
51736
51737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51739 if (!SWIG_IsOK(res1)) {
51740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51741 }
51742 arg1 = reinterpret_cast< wxSizer * >(argp1);
51743 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51744 if (!SWIG_IsOK(ecode2)) {
51745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
51746 }
51747 arg2 = static_cast< size_t >(val2);
51748 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
51749 if (!SWIG_IsOK(res3)) {
51750 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
51751 }
51752 {
51753 PyThreadState* __tstate = wxPyBeginAllowThreads();
51754 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
51755 wxPyEndAllowThreads(__tstate);
51756 if (PyErr_Occurred()) SWIG_fail;
51757 }
51758 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51759 return resultobj;
51760 fail:
51761 return NULL;
51762 }
51763
51764
51765 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51766 PyObject *resultobj = 0;
51767 wxSizer *arg1 = (wxSizer *) 0 ;
51768 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
51769 wxSizerItem *result = 0 ;
51770 void *argp1 = 0 ;
51771 int res1 = 0 ;
51772 int res2 = 0 ;
51773 PyObject * obj0 = 0 ;
51774 PyObject * obj1 = 0 ;
51775 char * kwnames[] = {
51776 (char *) "self",(char *) "item", NULL
51777 };
51778
51779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
51780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51781 if (!SWIG_IsOK(res1)) {
51782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51783 }
51784 arg1 = reinterpret_cast< wxSizer * >(argp1);
51785 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
51786 if (!SWIG_IsOK(res2)) {
51787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
51788 }
51789 {
51790 PyThreadState* __tstate = wxPyBeginAllowThreads();
51791 result = (wxSizerItem *)(arg1)->Prepend(arg2);
51792 wxPyEndAllowThreads(__tstate);
51793 if (PyErr_Occurred()) SWIG_fail;
51794 }
51795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51796 return resultobj;
51797 fail:
51798 return NULL;
51799 }
51800
51801
51802 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51803 PyObject *resultobj = 0;
51804 wxSizer *arg1 = (wxSizer *) 0 ;
51805 int arg2 ;
51806 int arg3 ;
51807 int arg4 ;
51808 int arg5 ;
51809 void *argp1 = 0 ;
51810 int res1 = 0 ;
51811 int val2 ;
51812 int ecode2 = 0 ;
51813 int val3 ;
51814 int ecode3 = 0 ;
51815 int val4 ;
51816 int ecode4 = 0 ;
51817 int val5 ;
51818 int ecode5 = 0 ;
51819 PyObject * obj0 = 0 ;
51820 PyObject * obj1 = 0 ;
51821 PyObject * obj2 = 0 ;
51822 PyObject * obj3 = 0 ;
51823 PyObject * obj4 = 0 ;
51824 char * kwnames[] = {
51825 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
51826 };
51827
51828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
51829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51830 if (!SWIG_IsOK(res1)) {
51831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
51832 }
51833 arg1 = reinterpret_cast< wxSizer * >(argp1);
51834 ecode2 = SWIG_AsVal_int(obj1, &val2);
51835 if (!SWIG_IsOK(ecode2)) {
51836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
51837 }
51838 arg2 = static_cast< int >(val2);
51839 ecode3 = SWIG_AsVal_int(obj2, &val3);
51840 if (!SWIG_IsOK(ecode3)) {
51841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
51842 }
51843 arg3 = static_cast< int >(val3);
51844 ecode4 = SWIG_AsVal_int(obj3, &val4);
51845 if (!SWIG_IsOK(ecode4)) {
51846 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
51847 }
51848 arg4 = static_cast< int >(val4);
51849 ecode5 = SWIG_AsVal_int(obj4, &val5);
51850 if (!SWIG_IsOK(ecode5)) {
51851 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
51852 }
51853 arg5 = static_cast< int >(val5);
51854 {
51855 PyThreadState* __tstate = wxPyBeginAllowThreads();
51856 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
51857 wxPyEndAllowThreads(__tstate);
51858 if (PyErr_Occurred()) SWIG_fail;
51859 }
51860 resultobj = SWIG_Py_Void();
51861 return resultobj;
51862 fail:
51863 return NULL;
51864 }
51865
51866
51867 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51868 PyObject *resultobj = 0;
51869 wxSizer *arg1 = (wxSizer *) 0 ;
51870 wxSize *arg2 = 0 ;
51871 void *argp1 = 0 ;
51872 int res1 = 0 ;
51873 wxSize temp2 ;
51874 PyObject * obj0 = 0 ;
51875 PyObject * obj1 = 0 ;
51876 char * kwnames[] = {
51877 (char *) "self",(char *) "size", NULL
51878 };
51879
51880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
51881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51882 if (!SWIG_IsOK(res1)) {
51883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
51884 }
51885 arg1 = reinterpret_cast< wxSizer * >(argp1);
51886 {
51887 arg2 = &temp2;
51888 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51889 }
51890 {
51891 PyThreadState* __tstate = wxPyBeginAllowThreads();
51892 (arg1)->SetMinSize((wxSize const &)*arg2);
51893 wxPyEndAllowThreads(__tstate);
51894 if (PyErr_Occurred()) SWIG_fail;
51895 }
51896 resultobj = SWIG_Py_Void();
51897 return resultobj;
51898 fail:
51899 return NULL;
51900 }
51901
51902
51903 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51904 PyObject *resultobj = 0;
51905 wxSizer *arg1 = (wxSizer *) 0 ;
51906 wxSize result;
51907 void *argp1 = 0 ;
51908 int res1 = 0 ;
51909 PyObject *swig_obj[1] ;
51910
51911 if (!args) SWIG_fail;
51912 swig_obj[0] = args;
51913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51914 if (!SWIG_IsOK(res1)) {
51915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
51916 }
51917 arg1 = reinterpret_cast< wxSizer * >(argp1);
51918 {
51919 PyThreadState* __tstate = wxPyBeginAllowThreads();
51920 result = (arg1)->GetSize();
51921 wxPyEndAllowThreads(__tstate);
51922 if (PyErr_Occurred()) SWIG_fail;
51923 }
51924 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51925 return resultobj;
51926 fail:
51927 return NULL;
51928 }
51929
51930
51931 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51932 PyObject *resultobj = 0;
51933 wxSizer *arg1 = (wxSizer *) 0 ;
51934 wxPoint result;
51935 void *argp1 = 0 ;
51936 int res1 = 0 ;
51937 PyObject *swig_obj[1] ;
51938
51939 if (!args) SWIG_fail;
51940 swig_obj[0] = args;
51941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51942 if (!SWIG_IsOK(res1)) {
51943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
51944 }
51945 arg1 = reinterpret_cast< wxSizer * >(argp1);
51946 {
51947 PyThreadState* __tstate = wxPyBeginAllowThreads();
51948 result = (arg1)->GetPosition();
51949 wxPyEndAllowThreads(__tstate);
51950 if (PyErr_Occurred()) SWIG_fail;
51951 }
51952 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
51953 return resultobj;
51954 fail:
51955 return NULL;
51956 }
51957
51958
51959 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51960 PyObject *resultobj = 0;
51961 wxSizer *arg1 = (wxSizer *) 0 ;
51962 wxSize result;
51963 void *argp1 = 0 ;
51964 int res1 = 0 ;
51965 PyObject *swig_obj[1] ;
51966
51967 if (!args) SWIG_fail;
51968 swig_obj[0] = args;
51969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51970 if (!SWIG_IsOK(res1)) {
51971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
51972 }
51973 arg1 = reinterpret_cast< wxSizer * >(argp1);
51974 {
51975 PyThreadState* __tstate = wxPyBeginAllowThreads();
51976 result = (arg1)->GetMinSize();
51977 wxPyEndAllowThreads(__tstate);
51978 if (PyErr_Occurred()) SWIG_fail;
51979 }
51980 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51981 return resultobj;
51982 fail:
51983 return NULL;
51984 }
51985
51986
51987 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51988 PyObject *resultobj = 0;
51989 wxSizer *arg1 = (wxSizer *) 0 ;
51990 void *argp1 = 0 ;
51991 int res1 = 0 ;
51992 PyObject *swig_obj[1] ;
51993
51994 if (!args) SWIG_fail;
51995 swig_obj[0] = args;
51996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51997 if (!SWIG_IsOK(res1)) {
51998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
51999 }
52000 arg1 = reinterpret_cast< wxSizer * >(argp1);
52001 {
52002 PyThreadState* __tstate = wxPyBeginAllowThreads();
52003 (arg1)->RecalcSizes();
52004 wxPyEndAllowThreads(__tstate);
52005 if (PyErr_Occurred()) SWIG_fail;
52006 }
52007 resultobj = SWIG_Py_Void();
52008 return resultobj;
52009 fail:
52010 return NULL;
52011 }
52012
52013
52014 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52015 PyObject *resultobj = 0;
52016 wxSizer *arg1 = (wxSizer *) 0 ;
52017 wxSize result;
52018 void *argp1 = 0 ;
52019 int res1 = 0 ;
52020 PyObject *swig_obj[1] ;
52021
52022 if (!args) SWIG_fail;
52023 swig_obj[0] = args;
52024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52025 if (!SWIG_IsOK(res1)) {
52026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
52027 }
52028 arg1 = reinterpret_cast< wxSizer * >(argp1);
52029 {
52030 PyThreadState* __tstate = wxPyBeginAllowThreads();
52031 result = (arg1)->CalcMin();
52032 wxPyEndAllowThreads(__tstate);
52033 if (PyErr_Occurred()) SWIG_fail;
52034 }
52035 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52036 return resultobj;
52037 fail:
52038 return NULL;
52039 }
52040
52041
52042 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52043 PyObject *resultobj = 0;
52044 wxSizer *arg1 = (wxSizer *) 0 ;
52045 void *argp1 = 0 ;
52046 int res1 = 0 ;
52047 PyObject *swig_obj[1] ;
52048
52049 if (!args) SWIG_fail;
52050 swig_obj[0] = args;
52051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52052 if (!SWIG_IsOK(res1)) {
52053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
52054 }
52055 arg1 = reinterpret_cast< wxSizer * >(argp1);
52056 {
52057 PyThreadState* __tstate = wxPyBeginAllowThreads();
52058 (arg1)->Layout();
52059 wxPyEndAllowThreads(__tstate);
52060 if (PyErr_Occurred()) SWIG_fail;
52061 }
52062 resultobj = SWIG_Py_Void();
52063 return resultobj;
52064 fail:
52065 return NULL;
52066 }
52067
52068
52069 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52070 PyObject *resultobj = 0;
52071 wxSizer *arg1 = (wxSizer *) 0 ;
52072 wxWindow *arg2 = (wxWindow *) 0 ;
52073 wxSize result;
52074 void *argp1 = 0 ;
52075 int res1 = 0 ;
52076 void *argp2 = 0 ;
52077 int res2 = 0 ;
52078 PyObject * obj0 = 0 ;
52079 PyObject * obj1 = 0 ;
52080 char * kwnames[] = {
52081 (char *) "self",(char *) "window", NULL
52082 };
52083
52084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
52085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52086 if (!SWIG_IsOK(res1)) {
52087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
52088 }
52089 arg1 = reinterpret_cast< wxSizer * >(argp1);
52090 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52091 if (!SWIG_IsOK(res2)) {
52092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
52093 }
52094 arg2 = reinterpret_cast< wxWindow * >(argp2);
52095 {
52096 PyThreadState* __tstate = wxPyBeginAllowThreads();
52097 result = (arg1)->Fit(arg2);
52098 wxPyEndAllowThreads(__tstate);
52099 if (PyErr_Occurred()) SWIG_fail;
52100 }
52101 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52102 return resultobj;
52103 fail:
52104 return NULL;
52105 }
52106
52107
52108 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52109 PyObject *resultobj = 0;
52110 wxSizer *arg1 = (wxSizer *) 0 ;
52111 wxWindow *arg2 = (wxWindow *) 0 ;
52112 void *argp1 = 0 ;
52113 int res1 = 0 ;
52114 void *argp2 = 0 ;
52115 int res2 = 0 ;
52116 PyObject * obj0 = 0 ;
52117 PyObject * obj1 = 0 ;
52118 char * kwnames[] = {
52119 (char *) "self",(char *) "window", NULL
52120 };
52121
52122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
52123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52124 if (!SWIG_IsOK(res1)) {
52125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
52126 }
52127 arg1 = reinterpret_cast< wxSizer * >(argp1);
52128 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52129 if (!SWIG_IsOK(res2)) {
52130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
52131 }
52132 arg2 = reinterpret_cast< wxWindow * >(argp2);
52133 {
52134 PyThreadState* __tstate = wxPyBeginAllowThreads();
52135 (arg1)->FitInside(arg2);
52136 wxPyEndAllowThreads(__tstate);
52137 if (PyErr_Occurred()) SWIG_fail;
52138 }
52139 resultobj = SWIG_Py_Void();
52140 return resultobj;
52141 fail:
52142 return NULL;
52143 }
52144
52145
52146 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52147 PyObject *resultobj = 0;
52148 wxSizer *arg1 = (wxSizer *) 0 ;
52149 wxWindow *arg2 = (wxWindow *) 0 ;
52150 void *argp1 = 0 ;
52151 int res1 = 0 ;
52152 void *argp2 = 0 ;
52153 int res2 = 0 ;
52154 PyObject * obj0 = 0 ;
52155 PyObject * obj1 = 0 ;
52156 char * kwnames[] = {
52157 (char *) "self",(char *) "window", NULL
52158 };
52159
52160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52162 if (!SWIG_IsOK(res1)) {
52163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52164 }
52165 arg1 = reinterpret_cast< wxSizer * >(argp1);
52166 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52167 if (!SWIG_IsOK(res2)) {
52168 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52169 }
52170 arg2 = reinterpret_cast< wxWindow * >(argp2);
52171 {
52172 PyThreadState* __tstate = wxPyBeginAllowThreads();
52173 (arg1)->SetSizeHints(arg2);
52174 wxPyEndAllowThreads(__tstate);
52175 if (PyErr_Occurred()) SWIG_fail;
52176 }
52177 resultobj = SWIG_Py_Void();
52178 return resultobj;
52179 fail:
52180 return NULL;
52181 }
52182
52183
52184 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52185 PyObject *resultobj = 0;
52186 wxSizer *arg1 = (wxSizer *) 0 ;
52187 wxWindow *arg2 = (wxWindow *) 0 ;
52188 void *argp1 = 0 ;
52189 int res1 = 0 ;
52190 void *argp2 = 0 ;
52191 int res2 = 0 ;
52192 PyObject * obj0 = 0 ;
52193 PyObject * obj1 = 0 ;
52194 char * kwnames[] = {
52195 (char *) "self",(char *) "window", NULL
52196 };
52197
52198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52200 if (!SWIG_IsOK(res1)) {
52201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52202 }
52203 arg1 = reinterpret_cast< wxSizer * >(argp1);
52204 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52205 if (!SWIG_IsOK(res2)) {
52206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52207 }
52208 arg2 = reinterpret_cast< wxWindow * >(argp2);
52209 {
52210 PyThreadState* __tstate = wxPyBeginAllowThreads();
52211 (arg1)->SetVirtualSizeHints(arg2);
52212 wxPyEndAllowThreads(__tstate);
52213 if (PyErr_Occurred()) SWIG_fail;
52214 }
52215 resultobj = SWIG_Py_Void();
52216 return resultobj;
52217 fail:
52218 return NULL;
52219 }
52220
52221
52222 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52223 PyObject *resultobj = 0;
52224 wxSizer *arg1 = (wxSizer *) 0 ;
52225 bool arg2 = (bool) false ;
52226 void *argp1 = 0 ;
52227 int res1 = 0 ;
52228 bool val2 ;
52229 int ecode2 = 0 ;
52230 PyObject * obj0 = 0 ;
52231 PyObject * obj1 = 0 ;
52232 char * kwnames[] = {
52233 (char *) "self",(char *) "deleteWindows", NULL
52234 };
52235
52236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
52237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52238 if (!SWIG_IsOK(res1)) {
52239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
52240 }
52241 arg1 = reinterpret_cast< wxSizer * >(argp1);
52242 if (obj1) {
52243 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52244 if (!SWIG_IsOK(ecode2)) {
52245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
52246 }
52247 arg2 = static_cast< bool >(val2);
52248 }
52249 {
52250 PyThreadState* __tstate = wxPyBeginAllowThreads();
52251 (arg1)->Clear(arg2);
52252 wxPyEndAllowThreads(__tstate);
52253 if (PyErr_Occurred()) SWIG_fail;
52254 }
52255 resultobj = SWIG_Py_Void();
52256 return resultobj;
52257 fail:
52258 return NULL;
52259 }
52260
52261
52262 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52263 PyObject *resultobj = 0;
52264 wxSizer *arg1 = (wxSizer *) 0 ;
52265 void *argp1 = 0 ;
52266 int res1 = 0 ;
52267 PyObject *swig_obj[1] ;
52268
52269 if (!args) SWIG_fail;
52270 swig_obj[0] = args;
52271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52272 if (!SWIG_IsOK(res1)) {
52273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
52274 }
52275 arg1 = reinterpret_cast< wxSizer * >(argp1);
52276 {
52277 PyThreadState* __tstate = wxPyBeginAllowThreads();
52278 (arg1)->DeleteWindows();
52279 wxPyEndAllowThreads(__tstate);
52280 if (PyErr_Occurred()) SWIG_fail;
52281 }
52282 resultobj = SWIG_Py_Void();
52283 return resultobj;
52284 fail:
52285 return NULL;
52286 }
52287
52288
52289 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52290 PyObject *resultobj = 0;
52291 wxSizer *arg1 = (wxSizer *) 0 ;
52292 PyObject *result = 0 ;
52293 void *argp1 = 0 ;
52294 int res1 = 0 ;
52295 PyObject *swig_obj[1] ;
52296
52297 if (!args) SWIG_fail;
52298 swig_obj[0] = args;
52299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52300 if (!SWIG_IsOK(res1)) {
52301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
52302 }
52303 arg1 = reinterpret_cast< wxSizer * >(argp1);
52304 {
52305 PyThreadState* __tstate = wxPyBeginAllowThreads();
52306 result = (PyObject *)wxSizer_GetChildren(arg1);
52307 wxPyEndAllowThreads(__tstate);
52308 if (PyErr_Occurred()) SWIG_fail;
52309 }
52310 resultobj = result;
52311 return resultobj;
52312 fail:
52313 return NULL;
52314 }
52315
52316
52317 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52318 PyObject *resultobj = 0;
52319 wxSizer *arg1 = (wxSizer *) 0 ;
52320 PyObject *arg2 = (PyObject *) 0 ;
52321 bool arg3 = (bool) true ;
52322 bool arg4 = (bool) false ;
52323 bool result;
52324 void *argp1 = 0 ;
52325 int res1 = 0 ;
52326 bool val3 ;
52327 int ecode3 = 0 ;
52328 bool val4 ;
52329 int ecode4 = 0 ;
52330 PyObject * obj0 = 0 ;
52331 PyObject * obj1 = 0 ;
52332 PyObject * obj2 = 0 ;
52333 PyObject * obj3 = 0 ;
52334 char * kwnames[] = {
52335 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
52336 };
52337
52338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52340 if (!SWIG_IsOK(res1)) {
52341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
52342 }
52343 arg1 = reinterpret_cast< wxSizer * >(argp1);
52344 arg2 = obj1;
52345 if (obj2) {
52346 ecode3 = SWIG_AsVal_bool(obj2, &val3);
52347 if (!SWIG_IsOK(ecode3)) {
52348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
52349 }
52350 arg3 = static_cast< bool >(val3);
52351 }
52352 if (obj3) {
52353 ecode4 = SWIG_AsVal_bool(obj3, &val4);
52354 if (!SWIG_IsOK(ecode4)) {
52355 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
52356 }
52357 arg4 = static_cast< bool >(val4);
52358 }
52359 {
52360 PyThreadState* __tstate = wxPyBeginAllowThreads();
52361 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
52362 wxPyEndAllowThreads(__tstate);
52363 if (PyErr_Occurred()) SWIG_fail;
52364 }
52365 {
52366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52367 }
52368 return resultobj;
52369 fail:
52370 return NULL;
52371 }
52372
52373
52374 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52375 PyObject *resultobj = 0;
52376 wxSizer *arg1 = (wxSizer *) 0 ;
52377 PyObject *arg2 = (PyObject *) 0 ;
52378 bool result;
52379 void *argp1 = 0 ;
52380 int res1 = 0 ;
52381 PyObject * obj0 = 0 ;
52382 PyObject * obj1 = 0 ;
52383 char * kwnames[] = {
52384 (char *) "self",(char *) "item", NULL
52385 };
52386
52387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
52388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52389 if (!SWIG_IsOK(res1)) {
52390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
52391 }
52392 arg1 = reinterpret_cast< wxSizer * >(argp1);
52393 arg2 = obj1;
52394 {
52395 PyThreadState* __tstate = wxPyBeginAllowThreads();
52396 result = (bool)wxSizer_IsShown(arg1,arg2);
52397 wxPyEndAllowThreads(__tstate);
52398 if (PyErr_Occurred()) SWIG_fail;
52399 }
52400 {
52401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52402 }
52403 return resultobj;
52404 fail:
52405 return NULL;
52406 }
52407
52408
52409 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52410 PyObject *resultobj = 0;
52411 wxSizer *arg1 = (wxSizer *) 0 ;
52412 bool arg2 ;
52413 void *argp1 = 0 ;
52414 int res1 = 0 ;
52415 bool val2 ;
52416 int ecode2 = 0 ;
52417 PyObject * obj0 = 0 ;
52418 PyObject * obj1 = 0 ;
52419 char * kwnames[] = {
52420 (char *) "self",(char *) "show", NULL
52421 };
52422
52423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
52424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52425 if (!SWIG_IsOK(res1)) {
52426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
52427 }
52428 arg1 = reinterpret_cast< wxSizer * >(argp1);
52429 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52430 if (!SWIG_IsOK(ecode2)) {
52431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
52432 }
52433 arg2 = static_cast< bool >(val2);
52434 {
52435 PyThreadState* __tstate = wxPyBeginAllowThreads();
52436 (arg1)->ShowItems(arg2);
52437 wxPyEndAllowThreads(__tstate);
52438 if (PyErr_Occurred()) SWIG_fail;
52439 }
52440 resultobj = SWIG_Py_Void();
52441 return resultobj;
52442 fail:
52443 return NULL;
52444 }
52445
52446
52447 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52448 PyObject *obj;
52449 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52450 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
52451 return SWIG_Py_Void();
52452 }
52453
52454 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52455 PyObject *resultobj = 0;
52456 wxPySizer *result = 0 ;
52457
52458 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
52459 {
52460 PyThreadState* __tstate = wxPyBeginAllowThreads();
52461 result = (wxPySizer *)new wxPySizer();
52462 wxPyEndAllowThreads(__tstate);
52463 if (PyErr_Occurred()) SWIG_fail;
52464 }
52465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
52466 return resultobj;
52467 fail:
52468 return NULL;
52469 }
52470
52471
52472 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52473 PyObject *resultobj = 0;
52474 wxPySizer *arg1 = (wxPySizer *) 0 ;
52475 PyObject *arg2 = (PyObject *) 0 ;
52476 PyObject *arg3 = (PyObject *) 0 ;
52477 void *argp1 = 0 ;
52478 int res1 = 0 ;
52479 PyObject * obj0 = 0 ;
52480 PyObject * obj1 = 0 ;
52481 PyObject * obj2 = 0 ;
52482 char * kwnames[] = {
52483 (char *) "self",(char *) "self",(char *) "_class", NULL
52484 };
52485
52486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
52488 if (!SWIG_IsOK(res1)) {
52489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
52490 }
52491 arg1 = reinterpret_cast< wxPySizer * >(argp1);
52492 arg2 = obj1;
52493 arg3 = obj2;
52494 {
52495 PyThreadState* __tstate = wxPyBeginAllowThreads();
52496 (arg1)->_setCallbackInfo(arg2,arg3);
52497 wxPyEndAllowThreads(__tstate);
52498 if (PyErr_Occurred()) SWIG_fail;
52499 }
52500 resultobj = SWIG_Py_Void();
52501 return resultobj;
52502 fail:
52503 return NULL;
52504 }
52505
52506
52507 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52508 PyObject *obj;
52509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52510 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
52511 return SWIG_Py_Void();
52512 }
52513
52514 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52515 return SWIG_Python_InitShadowInstance(args);
52516 }
52517
52518 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52519 PyObject *resultobj = 0;
52520 int arg1 = (int) wxHORIZONTAL ;
52521 wxBoxSizer *result = 0 ;
52522 int val1 ;
52523 int ecode1 = 0 ;
52524 PyObject * obj0 = 0 ;
52525 char * kwnames[] = {
52526 (char *) "orient", NULL
52527 };
52528
52529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
52530 if (obj0) {
52531 ecode1 = SWIG_AsVal_int(obj0, &val1);
52532 if (!SWIG_IsOK(ecode1)) {
52533 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
52534 }
52535 arg1 = static_cast< int >(val1);
52536 }
52537 {
52538 PyThreadState* __tstate = wxPyBeginAllowThreads();
52539 result = (wxBoxSizer *)new wxBoxSizer(arg1);
52540 wxPyEndAllowThreads(__tstate);
52541 if (PyErr_Occurred()) SWIG_fail;
52542 }
52543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
52544 return resultobj;
52545 fail:
52546 return NULL;
52547 }
52548
52549
52550 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52551 PyObject *resultobj = 0;
52552 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
52553 int result;
52554 void *argp1 = 0 ;
52555 int res1 = 0 ;
52556 PyObject *swig_obj[1] ;
52557
52558 if (!args) SWIG_fail;
52559 swig_obj[0] = args;
52560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
52561 if (!SWIG_IsOK(res1)) {
52562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
52563 }
52564 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
52565 {
52566 PyThreadState* __tstate = wxPyBeginAllowThreads();
52567 result = (int)(arg1)->GetOrientation();
52568 wxPyEndAllowThreads(__tstate);
52569 if (PyErr_Occurred()) SWIG_fail;
52570 }
52571 resultobj = SWIG_From_int(static_cast< int >(result));
52572 return resultobj;
52573 fail:
52574 return NULL;
52575 }
52576
52577
52578 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52579 PyObject *resultobj = 0;
52580 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
52581 int arg2 ;
52582 void *argp1 = 0 ;
52583 int res1 = 0 ;
52584 int val2 ;
52585 int ecode2 = 0 ;
52586 PyObject * obj0 = 0 ;
52587 PyObject * obj1 = 0 ;
52588 char * kwnames[] = {
52589 (char *) "self",(char *) "orient", NULL
52590 };
52591
52592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
52593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
52594 if (!SWIG_IsOK(res1)) {
52595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
52596 }
52597 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
52598 ecode2 = SWIG_AsVal_int(obj1, &val2);
52599 if (!SWIG_IsOK(ecode2)) {
52600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
52601 }
52602 arg2 = static_cast< int >(val2);
52603 {
52604 PyThreadState* __tstate = wxPyBeginAllowThreads();
52605 (arg1)->SetOrientation(arg2);
52606 wxPyEndAllowThreads(__tstate);
52607 if (PyErr_Occurred()) SWIG_fail;
52608 }
52609 resultobj = SWIG_Py_Void();
52610 return resultobj;
52611 fail:
52612 return NULL;
52613 }
52614
52615
52616 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52617 PyObject *obj;
52618 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52619 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
52620 return SWIG_Py_Void();
52621 }
52622
52623 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52624 return SWIG_Python_InitShadowInstance(args);
52625 }
52626
52627 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52628 PyObject *resultobj = 0;
52629 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
52630 int arg2 = (int) wxHORIZONTAL ;
52631 wxStaticBoxSizer *result = 0 ;
52632 void *argp1 = 0 ;
52633 int res1 = 0 ;
52634 int val2 ;
52635 int ecode2 = 0 ;
52636 PyObject * obj0 = 0 ;
52637 PyObject * obj1 = 0 ;
52638 char * kwnames[] = {
52639 (char *) "box",(char *) "orient", NULL
52640 };
52641
52642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
52643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
52644 if (!SWIG_IsOK(res1)) {
52645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
52646 }
52647 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
52648 if (obj1) {
52649 ecode2 = SWIG_AsVal_int(obj1, &val2);
52650 if (!SWIG_IsOK(ecode2)) {
52651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
52652 }
52653 arg2 = static_cast< int >(val2);
52654 }
52655 {
52656 PyThreadState* __tstate = wxPyBeginAllowThreads();
52657 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
52658 wxPyEndAllowThreads(__tstate);
52659 if (PyErr_Occurred()) SWIG_fail;
52660 }
52661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
52662 return resultobj;
52663 fail:
52664 return NULL;
52665 }
52666
52667
52668 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52669 PyObject *resultobj = 0;
52670 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
52671 wxStaticBox *result = 0 ;
52672 void *argp1 = 0 ;
52673 int res1 = 0 ;
52674 PyObject *swig_obj[1] ;
52675
52676 if (!args) SWIG_fail;
52677 swig_obj[0] = args;
52678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
52679 if (!SWIG_IsOK(res1)) {
52680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
52681 }
52682 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
52683 {
52684 PyThreadState* __tstate = wxPyBeginAllowThreads();
52685 result = (wxStaticBox *)(arg1)->GetStaticBox();
52686 wxPyEndAllowThreads(__tstate);
52687 if (PyErr_Occurred()) SWIG_fail;
52688 }
52689 {
52690 resultobj = wxPyMake_wxObject(result, (bool)0);
52691 }
52692 return resultobj;
52693 fail:
52694 return NULL;
52695 }
52696
52697
52698 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52699 PyObject *obj;
52700 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52701 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
52702 return SWIG_Py_Void();
52703 }
52704
52705 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52706 return SWIG_Python_InitShadowInstance(args);
52707 }
52708
52709 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52710 PyObject *resultobj = 0;
52711 int arg1 = (int) 1 ;
52712 int arg2 = (int) 0 ;
52713 int arg3 = (int) 0 ;
52714 int arg4 = (int) 0 ;
52715 wxGridSizer *result = 0 ;
52716 int val1 ;
52717 int ecode1 = 0 ;
52718 int val2 ;
52719 int ecode2 = 0 ;
52720 int val3 ;
52721 int ecode3 = 0 ;
52722 int val4 ;
52723 int ecode4 = 0 ;
52724 PyObject * obj0 = 0 ;
52725 PyObject * obj1 = 0 ;
52726 PyObject * obj2 = 0 ;
52727 PyObject * obj3 = 0 ;
52728 char * kwnames[] = {
52729 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
52730 };
52731
52732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52733 if (obj0) {
52734 ecode1 = SWIG_AsVal_int(obj0, &val1);
52735 if (!SWIG_IsOK(ecode1)) {
52736 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
52737 }
52738 arg1 = static_cast< int >(val1);
52739 }
52740 if (obj1) {
52741 ecode2 = SWIG_AsVal_int(obj1, &val2);
52742 if (!SWIG_IsOK(ecode2)) {
52743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
52744 }
52745 arg2 = static_cast< int >(val2);
52746 }
52747 if (obj2) {
52748 ecode3 = SWIG_AsVal_int(obj2, &val3);
52749 if (!SWIG_IsOK(ecode3)) {
52750 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
52751 }
52752 arg3 = static_cast< int >(val3);
52753 }
52754 if (obj3) {
52755 ecode4 = SWIG_AsVal_int(obj3, &val4);
52756 if (!SWIG_IsOK(ecode4)) {
52757 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
52758 }
52759 arg4 = static_cast< int >(val4);
52760 }
52761 {
52762 PyThreadState* __tstate = wxPyBeginAllowThreads();
52763 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
52764 wxPyEndAllowThreads(__tstate);
52765 if (PyErr_Occurred()) SWIG_fail;
52766 }
52767 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
52768 return resultobj;
52769 fail:
52770 return NULL;
52771 }
52772
52773
52774 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52775 PyObject *resultobj = 0;
52776 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52777 int arg2 ;
52778 void *argp1 = 0 ;
52779 int res1 = 0 ;
52780 int val2 ;
52781 int ecode2 = 0 ;
52782 PyObject * obj0 = 0 ;
52783 PyObject * obj1 = 0 ;
52784 char * kwnames[] = {
52785 (char *) "self",(char *) "cols", NULL
52786 };
52787
52788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
52789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52790 if (!SWIG_IsOK(res1)) {
52791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52792 }
52793 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52794 ecode2 = SWIG_AsVal_int(obj1, &val2);
52795 if (!SWIG_IsOK(ecode2)) {
52796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
52797 }
52798 arg2 = static_cast< int >(val2);
52799 {
52800 PyThreadState* __tstate = wxPyBeginAllowThreads();
52801 (arg1)->SetCols(arg2);
52802 wxPyEndAllowThreads(__tstate);
52803 if (PyErr_Occurred()) SWIG_fail;
52804 }
52805 resultobj = SWIG_Py_Void();
52806 return resultobj;
52807 fail:
52808 return NULL;
52809 }
52810
52811
52812 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52813 PyObject *resultobj = 0;
52814 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52815 int arg2 ;
52816 void *argp1 = 0 ;
52817 int res1 = 0 ;
52818 int val2 ;
52819 int ecode2 = 0 ;
52820 PyObject * obj0 = 0 ;
52821 PyObject * obj1 = 0 ;
52822 char * kwnames[] = {
52823 (char *) "self",(char *) "rows", NULL
52824 };
52825
52826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
52827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52828 if (!SWIG_IsOK(res1)) {
52829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52830 }
52831 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52832 ecode2 = SWIG_AsVal_int(obj1, &val2);
52833 if (!SWIG_IsOK(ecode2)) {
52834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
52835 }
52836 arg2 = static_cast< int >(val2);
52837 {
52838 PyThreadState* __tstate = wxPyBeginAllowThreads();
52839 (arg1)->SetRows(arg2);
52840 wxPyEndAllowThreads(__tstate);
52841 if (PyErr_Occurred()) SWIG_fail;
52842 }
52843 resultobj = SWIG_Py_Void();
52844 return resultobj;
52845 fail:
52846 return NULL;
52847 }
52848
52849
52850 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52851 PyObject *resultobj = 0;
52852 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52853 int arg2 ;
52854 void *argp1 = 0 ;
52855 int res1 = 0 ;
52856 int val2 ;
52857 int ecode2 = 0 ;
52858 PyObject * obj0 = 0 ;
52859 PyObject * obj1 = 0 ;
52860 char * kwnames[] = {
52861 (char *) "self",(char *) "gap", NULL
52862 };
52863
52864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
52865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52866 if (!SWIG_IsOK(res1)) {
52867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52868 }
52869 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52870 ecode2 = SWIG_AsVal_int(obj1, &val2);
52871 if (!SWIG_IsOK(ecode2)) {
52872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
52873 }
52874 arg2 = static_cast< int >(val2);
52875 {
52876 PyThreadState* __tstate = wxPyBeginAllowThreads();
52877 (arg1)->SetVGap(arg2);
52878 wxPyEndAllowThreads(__tstate);
52879 if (PyErr_Occurred()) SWIG_fail;
52880 }
52881 resultobj = SWIG_Py_Void();
52882 return resultobj;
52883 fail:
52884 return NULL;
52885 }
52886
52887
52888 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52889 PyObject *resultobj = 0;
52890 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52891 int arg2 ;
52892 void *argp1 = 0 ;
52893 int res1 = 0 ;
52894 int val2 ;
52895 int ecode2 = 0 ;
52896 PyObject * obj0 = 0 ;
52897 PyObject * obj1 = 0 ;
52898 char * kwnames[] = {
52899 (char *) "self",(char *) "gap", NULL
52900 };
52901
52902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
52903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52904 if (!SWIG_IsOK(res1)) {
52905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52906 }
52907 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52908 ecode2 = SWIG_AsVal_int(obj1, &val2);
52909 if (!SWIG_IsOK(ecode2)) {
52910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
52911 }
52912 arg2 = static_cast< int >(val2);
52913 {
52914 PyThreadState* __tstate = wxPyBeginAllowThreads();
52915 (arg1)->SetHGap(arg2);
52916 wxPyEndAllowThreads(__tstate);
52917 if (PyErr_Occurred()) SWIG_fail;
52918 }
52919 resultobj = SWIG_Py_Void();
52920 return resultobj;
52921 fail:
52922 return NULL;
52923 }
52924
52925
52926 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52927 PyObject *resultobj = 0;
52928 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52929 int result;
52930 void *argp1 = 0 ;
52931 int res1 = 0 ;
52932 PyObject *swig_obj[1] ;
52933
52934 if (!args) SWIG_fail;
52935 swig_obj[0] = args;
52936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52937 if (!SWIG_IsOK(res1)) {
52938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52939 }
52940 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52941 {
52942 PyThreadState* __tstate = wxPyBeginAllowThreads();
52943 result = (int)(arg1)->GetCols();
52944 wxPyEndAllowThreads(__tstate);
52945 if (PyErr_Occurred()) SWIG_fail;
52946 }
52947 resultobj = SWIG_From_int(static_cast< int >(result));
52948 return resultobj;
52949 fail:
52950 return NULL;
52951 }
52952
52953
52954 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52955 PyObject *resultobj = 0;
52956 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52957 int result;
52958 void *argp1 = 0 ;
52959 int res1 = 0 ;
52960 PyObject *swig_obj[1] ;
52961
52962 if (!args) SWIG_fail;
52963 swig_obj[0] = args;
52964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52965 if (!SWIG_IsOK(res1)) {
52966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52967 }
52968 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52969 {
52970 PyThreadState* __tstate = wxPyBeginAllowThreads();
52971 result = (int)(arg1)->GetRows();
52972 wxPyEndAllowThreads(__tstate);
52973 if (PyErr_Occurred()) SWIG_fail;
52974 }
52975 resultobj = SWIG_From_int(static_cast< int >(result));
52976 return resultobj;
52977 fail:
52978 return NULL;
52979 }
52980
52981
52982 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52983 PyObject *resultobj = 0;
52984 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52985 int result;
52986 void *argp1 = 0 ;
52987 int res1 = 0 ;
52988 PyObject *swig_obj[1] ;
52989
52990 if (!args) SWIG_fail;
52991 swig_obj[0] = args;
52992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52993 if (!SWIG_IsOK(res1)) {
52994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52995 }
52996 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52997 {
52998 PyThreadState* __tstate = wxPyBeginAllowThreads();
52999 result = (int)(arg1)->GetVGap();
53000 wxPyEndAllowThreads(__tstate);
53001 if (PyErr_Occurred()) SWIG_fail;
53002 }
53003 resultobj = SWIG_From_int(static_cast< int >(result));
53004 return resultobj;
53005 fail:
53006 return NULL;
53007 }
53008
53009
53010 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53011 PyObject *resultobj = 0;
53012 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53013 int result;
53014 void *argp1 = 0 ;
53015 int res1 = 0 ;
53016 PyObject *swig_obj[1] ;
53017
53018 if (!args) SWIG_fail;
53019 swig_obj[0] = args;
53020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53021 if (!SWIG_IsOK(res1)) {
53022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53023 }
53024 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53025 {
53026 PyThreadState* __tstate = wxPyBeginAllowThreads();
53027 result = (int)(arg1)->GetHGap();
53028 wxPyEndAllowThreads(__tstate);
53029 if (PyErr_Occurred()) SWIG_fail;
53030 }
53031 resultobj = SWIG_From_int(static_cast< int >(result));
53032 return resultobj;
53033 fail:
53034 return NULL;
53035 }
53036
53037
53038 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53039 PyObject *obj;
53040 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53041 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
53042 return SWIG_Py_Void();
53043 }
53044
53045 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53046 return SWIG_Python_InitShadowInstance(args);
53047 }
53048
53049 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53050 PyObject *resultobj = 0;
53051 int arg1 = (int) 1 ;
53052 int arg2 = (int) 0 ;
53053 int arg3 = (int) 0 ;
53054 int arg4 = (int) 0 ;
53055 wxFlexGridSizer *result = 0 ;
53056 int val1 ;
53057 int ecode1 = 0 ;
53058 int val2 ;
53059 int ecode2 = 0 ;
53060 int val3 ;
53061 int ecode3 = 0 ;
53062 int val4 ;
53063 int ecode4 = 0 ;
53064 PyObject * obj0 = 0 ;
53065 PyObject * obj1 = 0 ;
53066 PyObject * obj2 = 0 ;
53067 PyObject * obj3 = 0 ;
53068 char * kwnames[] = {
53069 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
53070 };
53071
53072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53073 if (obj0) {
53074 ecode1 = SWIG_AsVal_int(obj0, &val1);
53075 if (!SWIG_IsOK(ecode1)) {
53076 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
53077 }
53078 arg1 = static_cast< int >(val1);
53079 }
53080 if (obj1) {
53081 ecode2 = SWIG_AsVal_int(obj1, &val2);
53082 if (!SWIG_IsOK(ecode2)) {
53083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
53084 }
53085 arg2 = static_cast< int >(val2);
53086 }
53087 if (obj2) {
53088 ecode3 = SWIG_AsVal_int(obj2, &val3);
53089 if (!SWIG_IsOK(ecode3)) {
53090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
53091 }
53092 arg3 = static_cast< int >(val3);
53093 }
53094 if (obj3) {
53095 ecode4 = SWIG_AsVal_int(obj3, &val4);
53096 if (!SWIG_IsOK(ecode4)) {
53097 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
53098 }
53099 arg4 = static_cast< int >(val4);
53100 }
53101 {
53102 PyThreadState* __tstate = wxPyBeginAllowThreads();
53103 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
53104 wxPyEndAllowThreads(__tstate);
53105 if (PyErr_Occurred()) SWIG_fail;
53106 }
53107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
53108 return resultobj;
53109 fail:
53110 return NULL;
53111 }
53112
53113
53114 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53115 PyObject *resultobj = 0;
53116 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53117 size_t arg2 ;
53118 int arg3 = (int) 0 ;
53119 void *argp1 = 0 ;
53120 int res1 = 0 ;
53121 size_t val2 ;
53122 int ecode2 = 0 ;
53123 int val3 ;
53124 int ecode3 = 0 ;
53125 PyObject * obj0 = 0 ;
53126 PyObject * obj1 = 0 ;
53127 PyObject * obj2 = 0 ;
53128 char * kwnames[] = {
53129 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53130 };
53131
53132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53134 if (!SWIG_IsOK(res1)) {
53135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53136 }
53137 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53138 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53139 if (!SWIG_IsOK(ecode2)) {
53140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53141 }
53142 arg2 = static_cast< size_t >(val2);
53143 if (obj2) {
53144 ecode3 = SWIG_AsVal_int(obj2, &val3);
53145 if (!SWIG_IsOK(ecode3)) {
53146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
53147 }
53148 arg3 = static_cast< int >(val3);
53149 }
53150 {
53151 PyThreadState* __tstate = wxPyBeginAllowThreads();
53152 (arg1)->AddGrowableRow(arg2,arg3);
53153 wxPyEndAllowThreads(__tstate);
53154 if (PyErr_Occurred()) SWIG_fail;
53155 }
53156 resultobj = SWIG_Py_Void();
53157 return resultobj;
53158 fail:
53159 return NULL;
53160 }
53161
53162
53163 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53164 PyObject *resultobj = 0;
53165 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53166 size_t arg2 ;
53167 void *argp1 = 0 ;
53168 int res1 = 0 ;
53169 size_t val2 ;
53170 int ecode2 = 0 ;
53171 PyObject * obj0 = 0 ;
53172 PyObject * obj1 = 0 ;
53173 char * kwnames[] = {
53174 (char *) "self",(char *) "idx", NULL
53175 };
53176
53177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
53178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53179 if (!SWIG_IsOK(res1)) {
53180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53181 }
53182 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53183 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53184 if (!SWIG_IsOK(ecode2)) {
53185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53186 }
53187 arg2 = static_cast< size_t >(val2);
53188 {
53189 PyThreadState* __tstate = wxPyBeginAllowThreads();
53190 (arg1)->RemoveGrowableRow(arg2);
53191 wxPyEndAllowThreads(__tstate);
53192 if (PyErr_Occurred()) SWIG_fail;
53193 }
53194 resultobj = SWIG_Py_Void();
53195 return resultobj;
53196 fail:
53197 return NULL;
53198 }
53199
53200
53201 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53202 PyObject *resultobj = 0;
53203 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53204 size_t arg2 ;
53205 int arg3 = (int) 0 ;
53206 void *argp1 = 0 ;
53207 int res1 = 0 ;
53208 size_t val2 ;
53209 int ecode2 = 0 ;
53210 int val3 ;
53211 int ecode3 = 0 ;
53212 PyObject * obj0 = 0 ;
53213 PyObject * obj1 = 0 ;
53214 PyObject * obj2 = 0 ;
53215 char * kwnames[] = {
53216 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53217 };
53218
53219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53221 if (!SWIG_IsOK(res1)) {
53222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53223 }
53224 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53225 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53226 if (!SWIG_IsOK(ecode2)) {
53227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53228 }
53229 arg2 = static_cast< size_t >(val2);
53230 if (obj2) {
53231 ecode3 = SWIG_AsVal_int(obj2, &val3);
53232 if (!SWIG_IsOK(ecode3)) {
53233 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
53234 }
53235 arg3 = static_cast< int >(val3);
53236 }
53237 {
53238 PyThreadState* __tstate = wxPyBeginAllowThreads();
53239 (arg1)->AddGrowableCol(arg2,arg3);
53240 wxPyEndAllowThreads(__tstate);
53241 if (PyErr_Occurred()) SWIG_fail;
53242 }
53243 resultobj = SWIG_Py_Void();
53244 return resultobj;
53245 fail:
53246 return NULL;
53247 }
53248
53249
53250 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53251 PyObject *resultobj = 0;
53252 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53253 size_t arg2 ;
53254 void *argp1 = 0 ;
53255 int res1 = 0 ;
53256 size_t val2 ;
53257 int ecode2 = 0 ;
53258 PyObject * obj0 = 0 ;
53259 PyObject * obj1 = 0 ;
53260 char * kwnames[] = {
53261 (char *) "self",(char *) "idx", NULL
53262 };
53263
53264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
53265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53266 if (!SWIG_IsOK(res1)) {
53267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53268 }
53269 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53270 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53271 if (!SWIG_IsOK(ecode2)) {
53272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53273 }
53274 arg2 = static_cast< size_t >(val2);
53275 {
53276 PyThreadState* __tstate = wxPyBeginAllowThreads();
53277 (arg1)->RemoveGrowableCol(arg2);
53278 wxPyEndAllowThreads(__tstate);
53279 if (PyErr_Occurred()) SWIG_fail;
53280 }
53281 resultobj = SWIG_Py_Void();
53282 return resultobj;
53283 fail:
53284 return NULL;
53285 }
53286
53287
53288 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53289 PyObject *resultobj = 0;
53290 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53291 int arg2 ;
53292 void *argp1 = 0 ;
53293 int res1 = 0 ;
53294 int val2 ;
53295 int ecode2 = 0 ;
53296 PyObject * obj0 = 0 ;
53297 PyObject * obj1 = 0 ;
53298 char * kwnames[] = {
53299 (char *) "self",(char *) "direction", NULL
53300 };
53301
53302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
53303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53304 if (!SWIG_IsOK(res1)) {
53305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53306 }
53307 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53308 ecode2 = SWIG_AsVal_int(obj1, &val2);
53309 if (!SWIG_IsOK(ecode2)) {
53310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
53311 }
53312 arg2 = static_cast< int >(val2);
53313 {
53314 PyThreadState* __tstate = wxPyBeginAllowThreads();
53315 (arg1)->SetFlexibleDirection(arg2);
53316 wxPyEndAllowThreads(__tstate);
53317 if (PyErr_Occurred()) SWIG_fail;
53318 }
53319 resultobj = SWIG_Py_Void();
53320 return resultobj;
53321 fail:
53322 return NULL;
53323 }
53324
53325
53326 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53327 PyObject *resultobj = 0;
53328 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53329 int result;
53330 void *argp1 = 0 ;
53331 int res1 = 0 ;
53332 PyObject *swig_obj[1] ;
53333
53334 if (!args) SWIG_fail;
53335 swig_obj[0] = args;
53336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53337 if (!SWIG_IsOK(res1)) {
53338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53339 }
53340 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53341 {
53342 PyThreadState* __tstate = wxPyBeginAllowThreads();
53343 result = (int)(arg1)->GetFlexibleDirection();
53344 wxPyEndAllowThreads(__tstate);
53345 if (PyErr_Occurred()) SWIG_fail;
53346 }
53347 resultobj = SWIG_From_int(static_cast< int >(result));
53348 return resultobj;
53349 fail:
53350 return NULL;
53351 }
53352
53353
53354 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53355 PyObject *resultobj = 0;
53356 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53357 wxFlexSizerGrowMode arg2 ;
53358 void *argp1 = 0 ;
53359 int res1 = 0 ;
53360 int val2 ;
53361 int ecode2 = 0 ;
53362 PyObject * obj0 = 0 ;
53363 PyObject * obj1 = 0 ;
53364 char * kwnames[] = {
53365 (char *) "self",(char *) "mode", NULL
53366 };
53367
53368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
53369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53370 if (!SWIG_IsOK(res1)) {
53371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53372 }
53373 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53374 ecode2 = SWIG_AsVal_int(obj1, &val2);
53375 if (!SWIG_IsOK(ecode2)) {
53376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
53377 }
53378 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
53379 {
53380 PyThreadState* __tstate = wxPyBeginAllowThreads();
53381 (arg1)->SetNonFlexibleGrowMode(arg2);
53382 wxPyEndAllowThreads(__tstate);
53383 if (PyErr_Occurred()) SWIG_fail;
53384 }
53385 resultobj = SWIG_Py_Void();
53386 return resultobj;
53387 fail:
53388 return NULL;
53389 }
53390
53391
53392 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53393 PyObject *resultobj = 0;
53394 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53395 wxFlexSizerGrowMode result;
53396 void *argp1 = 0 ;
53397 int res1 = 0 ;
53398 PyObject *swig_obj[1] ;
53399
53400 if (!args) SWIG_fail;
53401 swig_obj[0] = args;
53402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53403 if (!SWIG_IsOK(res1)) {
53404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53405 }
53406 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53407 {
53408 PyThreadState* __tstate = wxPyBeginAllowThreads();
53409 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
53410 wxPyEndAllowThreads(__tstate);
53411 if (PyErr_Occurred()) SWIG_fail;
53412 }
53413 resultobj = SWIG_From_int(static_cast< int >(result));
53414 return resultobj;
53415 fail:
53416 return NULL;
53417 }
53418
53419
53420 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53421 PyObject *resultobj = 0;
53422 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53423 wxArrayInt *result = 0 ;
53424 void *argp1 = 0 ;
53425 int res1 = 0 ;
53426 PyObject *swig_obj[1] ;
53427
53428 if (!args) SWIG_fail;
53429 swig_obj[0] = args;
53430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53431 if (!SWIG_IsOK(res1)) {
53432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
53433 }
53434 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53435 {
53436 PyThreadState* __tstate = wxPyBeginAllowThreads();
53437 {
53438 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
53439 result = (wxArrayInt *) &_result_ref;
53440 }
53441 wxPyEndAllowThreads(__tstate);
53442 if (PyErr_Occurred()) SWIG_fail;
53443 }
53444 {
53445 resultobj = wxArrayInt2PyList_helper(*result);
53446 }
53447 return resultobj;
53448 fail:
53449 return NULL;
53450 }
53451
53452
53453 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53454 PyObject *resultobj = 0;
53455 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53456 wxArrayInt *result = 0 ;
53457 void *argp1 = 0 ;
53458 int res1 = 0 ;
53459 PyObject *swig_obj[1] ;
53460
53461 if (!args) SWIG_fail;
53462 swig_obj[0] = args;
53463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53464 if (!SWIG_IsOK(res1)) {
53465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
53466 }
53467 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53468 {
53469 PyThreadState* __tstate = wxPyBeginAllowThreads();
53470 {
53471 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
53472 result = (wxArrayInt *) &_result_ref;
53473 }
53474 wxPyEndAllowThreads(__tstate);
53475 if (PyErr_Occurred()) SWIG_fail;
53476 }
53477 {
53478 resultobj = wxArrayInt2PyList_helper(*result);
53479 }
53480 return resultobj;
53481 fail:
53482 return NULL;
53483 }
53484
53485
53486 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53487 PyObject *obj;
53488 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53489 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
53490 return SWIG_Py_Void();
53491 }
53492
53493 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53494 return SWIG_Python_InitShadowInstance(args);
53495 }
53496
53497 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53498 PyObject *resultobj = 0;
53499 wxStdDialogButtonSizer *result = 0 ;
53500
53501 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
53502 {
53503 PyThreadState* __tstate = wxPyBeginAllowThreads();
53504 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
53505 wxPyEndAllowThreads(__tstate);
53506 if (PyErr_Occurred()) SWIG_fail;
53507 }
53508 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
53509 return resultobj;
53510 fail:
53511 return NULL;
53512 }
53513
53514
53515 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53516 PyObject *resultobj = 0;
53517 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53518 wxButton *arg2 = (wxButton *) 0 ;
53519 void *argp1 = 0 ;
53520 int res1 = 0 ;
53521 void *argp2 = 0 ;
53522 int res2 = 0 ;
53523 PyObject * obj0 = 0 ;
53524 PyObject * obj1 = 0 ;
53525 char * kwnames[] = {
53526 (char *) "self",(char *) "button", NULL
53527 };
53528
53529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
53530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53531 if (!SWIG_IsOK(res1)) {
53532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53533 }
53534 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53535 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53536 if (!SWIG_IsOK(res2)) {
53537 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
53538 }
53539 arg2 = reinterpret_cast< wxButton * >(argp2);
53540 {
53541 PyThreadState* __tstate = wxPyBeginAllowThreads();
53542 (arg1)->AddButton(arg2);
53543 wxPyEndAllowThreads(__tstate);
53544 if (PyErr_Occurred()) SWIG_fail;
53545 }
53546 resultobj = SWIG_Py_Void();
53547 return resultobj;
53548 fail:
53549 return NULL;
53550 }
53551
53552
53553 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53554 PyObject *resultobj = 0;
53555 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53556 void *argp1 = 0 ;
53557 int res1 = 0 ;
53558 PyObject *swig_obj[1] ;
53559
53560 if (!args) SWIG_fail;
53561 swig_obj[0] = args;
53562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53563 if (!SWIG_IsOK(res1)) {
53564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53565 }
53566 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53567 {
53568 PyThreadState* __tstate = wxPyBeginAllowThreads();
53569 (arg1)->Realize();
53570 wxPyEndAllowThreads(__tstate);
53571 if (PyErr_Occurred()) SWIG_fail;
53572 }
53573 resultobj = SWIG_Py_Void();
53574 return resultobj;
53575 fail:
53576 return NULL;
53577 }
53578
53579
53580 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53581 PyObject *resultobj = 0;
53582 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53583 wxButton *arg2 = (wxButton *) 0 ;
53584 void *argp1 = 0 ;
53585 int res1 = 0 ;
53586 void *argp2 = 0 ;
53587 int res2 = 0 ;
53588 PyObject * obj0 = 0 ;
53589 PyObject * obj1 = 0 ;
53590 char * kwnames[] = {
53591 (char *) "self",(char *) "button", NULL
53592 };
53593
53594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
53595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53596 if (!SWIG_IsOK(res1)) {
53597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53598 }
53599 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53600 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53601 if (!SWIG_IsOK(res2)) {
53602 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
53603 }
53604 arg2 = reinterpret_cast< wxButton * >(argp2);
53605 {
53606 PyThreadState* __tstate = wxPyBeginAllowThreads();
53607 (arg1)->SetAffirmativeButton(arg2);
53608 wxPyEndAllowThreads(__tstate);
53609 if (PyErr_Occurred()) SWIG_fail;
53610 }
53611 resultobj = SWIG_Py_Void();
53612 return resultobj;
53613 fail:
53614 return NULL;
53615 }
53616
53617
53618 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53619 PyObject *resultobj = 0;
53620 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53621 wxButton *arg2 = (wxButton *) 0 ;
53622 void *argp1 = 0 ;
53623 int res1 = 0 ;
53624 void *argp2 = 0 ;
53625 int res2 = 0 ;
53626 PyObject * obj0 = 0 ;
53627 PyObject * obj1 = 0 ;
53628 char * kwnames[] = {
53629 (char *) "self",(char *) "button", NULL
53630 };
53631
53632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
53633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53634 if (!SWIG_IsOK(res1)) {
53635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53636 }
53637 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53638 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53639 if (!SWIG_IsOK(res2)) {
53640 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
53641 }
53642 arg2 = reinterpret_cast< wxButton * >(argp2);
53643 {
53644 PyThreadState* __tstate = wxPyBeginAllowThreads();
53645 (arg1)->SetNegativeButton(arg2);
53646 wxPyEndAllowThreads(__tstate);
53647 if (PyErr_Occurred()) SWIG_fail;
53648 }
53649 resultobj = SWIG_Py_Void();
53650 return resultobj;
53651 fail:
53652 return NULL;
53653 }
53654
53655
53656 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53657 PyObject *resultobj = 0;
53658 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53659 wxButton *arg2 = (wxButton *) 0 ;
53660 void *argp1 = 0 ;
53661 int res1 = 0 ;
53662 void *argp2 = 0 ;
53663 int res2 = 0 ;
53664 PyObject * obj0 = 0 ;
53665 PyObject * obj1 = 0 ;
53666 char * kwnames[] = {
53667 (char *) "self",(char *) "button", NULL
53668 };
53669
53670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
53671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53672 if (!SWIG_IsOK(res1)) {
53673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53674 }
53675 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53676 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53677 if (!SWIG_IsOK(res2)) {
53678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
53679 }
53680 arg2 = reinterpret_cast< wxButton * >(argp2);
53681 {
53682 PyThreadState* __tstate = wxPyBeginAllowThreads();
53683 (arg1)->SetCancelButton(arg2);
53684 wxPyEndAllowThreads(__tstate);
53685 if (PyErr_Occurred()) SWIG_fail;
53686 }
53687 resultobj = SWIG_Py_Void();
53688 return resultobj;
53689 fail:
53690 return NULL;
53691 }
53692
53693
53694 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53695 PyObject *resultobj = 0;
53696 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53697 wxButton *result = 0 ;
53698 void *argp1 = 0 ;
53699 int res1 = 0 ;
53700 PyObject *swig_obj[1] ;
53701
53702 if (!args) SWIG_fail;
53703 swig_obj[0] = args;
53704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53705 if (!SWIG_IsOK(res1)) {
53706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53707 }
53708 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53709 {
53710 PyThreadState* __tstate = wxPyBeginAllowThreads();
53711 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
53712 wxPyEndAllowThreads(__tstate);
53713 if (PyErr_Occurred()) SWIG_fail;
53714 }
53715 {
53716 resultobj = wxPyMake_wxObject(result, (bool)0);
53717 }
53718 return resultobj;
53719 fail:
53720 return NULL;
53721 }
53722
53723
53724 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53725 PyObject *resultobj = 0;
53726 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53727 wxButton *result = 0 ;
53728 void *argp1 = 0 ;
53729 int res1 = 0 ;
53730 PyObject *swig_obj[1] ;
53731
53732 if (!args) SWIG_fail;
53733 swig_obj[0] = args;
53734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53735 if (!SWIG_IsOK(res1)) {
53736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53737 }
53738 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53739 {
53740 PyThreadState* __tstate = wxPyBeginAllowThreads();
53741 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
53742 wxPyEndAllowThreads(__tstate);
53743 if (PyErr_Occurred()) SWIG_fail;
53744 }
53745 {
53746 resultobj = wxPyMake_wxObject(result, (bool)0);
53747 }
53748 return resultobj;
53749 fail:
53750 return NULL;
53751 }
53752
53753
53754 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53755 PyObject *resultobj = 0;
53756 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53757 wxButton *result = 0 ;
53758 void *argp1 = 0 ;
53759 int res1 = 0 ;
53760 PyObject *swig_obj[1] ;
53761
53762 if (!args) SWIG_fail;
53763 swig_obj[0] = args;
53764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53765 if (!SWIG_IsOK(res1)) {
53766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53767 }
53768 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53769 {
53770 PyThreadState* __tstate = wxPyBeginAllowThreads();
53771 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
53772 wxPyEndAllowThreads(__tstate);
53773 if (PyErr_Occurred()) SWIG_fail;
53774 }
53775 {
53776 resultobj = wxPyMake_wxObject(result, (bool)0);
53777 }
53778 return resultobj;
53779 fail:
53780 return NULL;
53781 }
53782
53783
53784 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53785 PyObject *resultobj = 0;
53786 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53787 wxButton *result = 0 ;
53788 void *argp1 = 0 ;
53789 int res1 = 0 ;
53790 PyObject *swig_obj[1] ;
53791
53792 if (!args) SWIG_fail;
53793 swig_obj[0] = args;
53794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53795 if (!SWIG_IsOK(res1)) {
53796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53797 }
53798 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53799 {
53800 PyThreadState* __tstate = wxPyBeginAllowThreads();
53801 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
53802 wxPyEndAllowThreads(__tstate);
53803 if (PyErr_Occurred()) SWIG_fail;
53804 }
53805 {
53806 resultobj = wxPyMake_wxObject(result, (bool)0);
53807 }
53808 return resultobj;
53809 fail:
53810 return NULL;
53811 }
53812
53813
53814 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53815 PyObject *resultobj = 0;
53816 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53817 wxButton *result = 0 ;
53818 void *argp1 = 0 ;
53819 int res1 = 0 ;
53820 PyObject *swig_obj[1] ;
53821
53822 if (!args) SWIG_fail;
53823 swig_obj[0] = args;
53824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53825 if (!SWIG_IsOK(res1)) {
53826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53827 }
53828 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53829 {
53830 PyThreadState* __tstate = wxPyBeginAllowThreads();
53831 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
53832 wxPyEndAllowThreads(__tstate);
53833 if (PyErr_Occurred()) SWIG_fail;
53834 }
53835 {
53836 resultobj = wxPyMake_wxObject(result, (bool)0);
53837 }
53838 return resultobj;
53839 fail:
53840 return NULL;
53841 }
53842
53843
53844 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53845 PyObject *obj;
53846 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53847 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
53848 return SWIG_Py_Void();
53849 }
53850
53851 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53852 return SWIG_Python_InitShadowInstance(args);
53853 }
53854
53855 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53856 PyObject *resultobj = 0;
53857 int arg1 = (int) 0 ;
53858 int arg2 = (int) 0 ;
53859 wxGBPosition *result = 0 ;
53860 int val1 ;
53861 int ecode1 = 0 ;
53862 int val2 ;
53863 int ecode2 = 0 ;
53864 PyObject * obj0 = 0 ;
53865 PyObject * obj1 = 0 ;
53866 char * kwnames[] = {
53867 (char *) "row",(char *) "col", NULL
53868 };
53869
53870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
53871 if (obj0) {
53872 ecode1 = SWIG_AsVal_int(obj0, &val1);
53873 if (!SWIG_IsOK(ecode1)) {
53874 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
53875 }
53876 arg1 = static_cast< int >(val1);
53877 }
53878 if (obj1) {
53879 ecode2 = SWIG_AsVal_int(obj1, &val2);
53880 if (!SWIG_IsOK(ecode2)) {
53881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
53882 }
53883 arg2 = static_cast< int >(val2);
53884 }
53885 {
53886 PyThreadState* __tstate = wxPyBeginAllowThreads();
53887 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
53888 wxPyEndAllowThreads(__tstate);
53889 if (PyErr_Occurred()) SWIG_fail;
53890 }
53891 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
53892 return resultobj;
53893 fail:
53894 return NULL;
53895 }
53896
53897
53898 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53899 PyObject *resultobj = 0;
53900 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
53901 void *argp1 = 0 ;
53902 int res1 = 0 ;
53903 PyObject *swig_obj[1] ;
53904
53905 if (!args) SWIG_fail;
53906 swig_obj[0] = args;
53907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
53908 if (!SWIG_IsOK(res1)) {
53909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
53910 }
53911 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
53912 {
53913 PyThreadState* __tstate = wxPyBeginAllowThreads();
53914 delete arg1;
53915
53916 wxPyEndAllowThreads(__tstate);
53917 if (PyErr_Occurred()) SWIG_fail;
53918 }
53919 resultobj = SWIG_Py_Void();
53920 return resultobj;
53921 fail:
53922 return NULL;
53923 }
53924
53925
53926 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53927 PyObject *resultobj = 0;
53928 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
53929 int result;
53930 void *argp1 = 0 ;
53931 int res1 = 0 ;
53932 PyObject *swig_obj[1] ;
53933
53934 if (!args) SWIG_fail;
53935 swig_obj[0] = args;
53936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
53937 if (!SWIG_IsOK(res1)) {
53938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
53939 }
53940 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
53941 {
53942 PyThreadState* __tstate = wxPyBeginAllowThreads();
53943 result = (int)((wxGBPosition const *)arg1)->GetRow();
53944 wxPyEndAllowThreads(__tstate);
53945 if (PyErr_Occurred()) SWIG_fail;
53946 }
53947 resultobj = SWIG_From_int(static_cast< int >(result));
53948 return resultobj;
53949 fail:
53950 return NULL;
53951 }
53952
53953
53954 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53955 PyObject *resultobj = 0;
53956 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
53957 int result;
53958 void *argp1 = 0 ;
53959 int res1 = 0 ;
53960 PyObject *swig_obj[1] ;
53961
53962 if (!args) SWIG_fail;
53963 swig_obj[0] = args;
53964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
53965 if (!SWIG_IsOK(res1)) {
53966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
53967 }
53968 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
53969 {
53970 PyThreadState* __tstate = wxPyBeginAllowThreads();
53971 result = (int)((wxGBPosition const *)arg1)->GetCol();
53972 wxPyEndAllowThreads(__tstate);
53973 if (PyErr_Occurred()) SWIG_fail;
53974 }
53975 resultobj = SWIG_From_int(static_cast< int >(result));
53976 return resultobj;
53977 fail:
53978 return NULL;
53979 }
53980
53981
53982 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53983 PyObject *resultobj = 0;
53984 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
53985 int arg2 ;
53986 void *argp1 = 0 ;
53987 int res1 = 0 ;
53988 int val2 ;
53989 int ecode2 = 0 ;
53990 PyObject * obj0 = 0 ;
53991 PyObject * obj1 = 0 ;
53992 char * kwnames[] = {
53993 (char *) "self",(char *) "row", NULL
53994 };
53995
53996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
53997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
53998 if (!SWIG_IsOK(res1)) {
53999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54000 }
54001 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54002 ecode2 = SWIG_AsVal_int(obj1, &val2);
54003 if (!SWIG_IsOK(ecode2)) {
54004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
54005 }
54006 arg2 = static_cast< int >(val2);
54007 {
54008 PyThreadState* __tstate = wxPyBeginAllowThreads();
54009 (arg1)->SetRow(arg2);
54010 wxPyEndAllowThreads(__tstate);
54011 if (PyErr_Occurred()) SWIG_fail;
54012 }
54013 resultobj = SWIG_Py_Void();
54014 return resultobj;
54015 fail:
54016 return NULL;
54017 }
54018
54019
54020 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54021 PyObject *resultobj = 0;
54022 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54023 int arg2 ;
54024 void *argp1 = 0 ;
54025 int res1 = 0 ;
54026 int val2 ;
54027 int ecode2 = 0 ;
54028 PyObject * obj0 = 0 ;
54029 PyObject * obj1 = 0 ;
54030 char * kwnames[] = {
54031 (char *) "self",(char *) "col", NULL
54032 };
54033
54034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
54035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54036 if (!SWIG_IsOK(res1)) {
54037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54038 }
54039 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54040 ecode2 = SWIG_AsVal_int(obj1, &val2);
54041 if (!SWIG_IsOK(ecode2)) {
54042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
54043 }
54044 arg2 = static_cast< int >(val2);
54045 {
54046 PyThreadState* __tstate = wxPyBeginAllowThreads();
54047 (arg1)->SetCol(arg2);
54048 wxPyEndAllowThreads(__tstate);
54049 if (PyErr_Occurred()) SWIG_fail;
54050 }
54051 resultobj = SWIG_Py_Void();
54052 return resultobj;
54053 fail:
54054 return NULL;
54055 }
54056
54057
54058 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54059 PyObject *resultobj = 0;
54060 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54061 PyObject *arg2 = (PyObject *) 0 ;
54062 bool result;
54063 void *argp1 = 0 ;
54064 int res1 = 0 ;
54065 PyObject * obj0 = 0 ;
54066 PyObject * obj1 = 0 ;
54067 char * kwnames[] = {
54068 (char *) "self",(char *) "other", NULL
54069 };
54070
54071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
54072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54073 if (!SWIG_IsOK(res1)) {
54074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54075 }
54076 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54077 arg2 = obj1;
54078 {
54079 result = (bool)wxGBPosition___eq__(arg1,arg2);
54080 if (PyErr_Occurred()) SWIG_fail;
54081 }
54082 {
54083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54084 }
54085 return resultobj;
54086 fail:
54087 return NULL;
54088 }
54089
54090
54091 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54092 PyObject *resultobj = 0;
54093 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54094 PyObject *arg2 = (PyObject *) 0 ;
54095 bool result;
54096 void *argp1 = 0 ;
54097 int res1 = 0 ;
54098 PyObject * obj0 = 0 ;
54099 PyObject * obj1 = 0 ;
54100 char * kwnames[] = {
54101 (char *) "self",(char *) "other", NULL
54102 };
54103
54104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
54105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54106 if (!SWIG_IsOK(res1)) {
54107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54108 }
54109 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54110 arg2 = obj1;
54111 {
54112 result = (bool)wxGBPosition___ne__(arg1,arg2);
54113 if (PyErr_Occurred()) SWIG_fail;
54114 }
54115 {
54116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54117 }
54118 return resultobj;
54119 fail:
54120 return NULL;
54121 }
54122
54123
54124 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54125 PyObject *resultobj = 0;
54126 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54127 int arg2 = (int) 0 ;
54128 int arg3 = (int) 0 ;
54129 void *argp1 = 0 ;
54130 int res1 = 0 ;
54131 int val2 ;
54132 int ecode2 = 0 ;
54133 int val3 ;
54134 int ecode3 = 0 ;
54135 PyObject * obj0 = 0 ;
54136 PyObject * obj1 = 0 ;
54137 PyObject * obj2 = 0 ;
54138 char * kwnames[] = {
54139 (char *) "self",(char *) "row",(char *) "col", NULL
54140 };
54141
54142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54144 if (!SWIG_IsOK(res1)) {
54145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54146 }
54147 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54148 if (obj1) {
54149 ecode2 = SWIG_AsVal_int(obj1, &val2);
54150 if (!SWIG_IsOK(ecode2)) {
54151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
54152 }
54153 arg2 = static_cast< int >(val2);
54154 }
54155 if (obj2) {
54156 ecode3 = SWIG_AsVal_int(obj2, &val3);
54157 if (!SWIG_IsOK(ecode3)) {
54158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
54159 }
54160 arg3 = static_cast< int >(val3);
54161 }
54162 {
54163 PyThreadState* __tstate = wxPyBeginAllowThreads();
54164 wxGBPosition_Set(arg1,arg2,arg3);
54165 wxPyEndAllowThreads(__tstate);
54166 if (PyErr_Occurred()) SWIG_fail;
54167 }
54168 resultobj = SWIG_Py_Void();
54169 return resultobj;
54170 fail:
54171 return NULL;
54172 }
54173
54174
54175 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54176 PyObject *resultobj = 0;
54177 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54178 PyObject *result = 0 ;
54179 void *argp1 = 0 ;
54180 int res1 = 0 ;
54181 PyObject *swig_obj[1] ;
54182
54183 if (!args) SWIG_fail;
54184 swig_obj[0] = args;
54185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54186 if (!SWIG_IsOK(res1)) {
54187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54188 }
54189 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54190 {
54191 PyThreadState* __tstate = wxPyBeginAllowThreads();
54192 result = (PyObject *)wxGBPosition_Get(arg1);
54193 wxPyEndAllowThreads(__tstate);
54194 if (PyErr_Occurred()) SWIG_fail;
54195 }
54196 resultobj = result;
54197 return resultobj;
54198 fail:
54199 return NULL;
54200 }
54201
54202
54203 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54204 PyObject *obj;
54205 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54206 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
54207 return SWIG_Py_Void();
54208 }
54209
54210 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54211 return SWIG_Python_InitShadowInstance(args);
54212 }
54213
54214 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54215 PyObject *resultobj = 0;
54216 int arg1 = (int) 1 ;
54217 int arg2 = (int) 1 ;
54218 wxGBSpan *result = 0 ;
54219 int val1 ;
54220 int ecode1 = 0 ;
54221 int val2 ;
54222 int ecode2 = 0 ;
54223 PyObject * obj0 = 0 ;
54224 PyObject * obj1 = 0 ;
54225 char * kwnames[] = {
54226 (char *) "rowspan",(char *) "colspan", NULL
54227 };
54228
54229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
54230 if (obj0) {
54231 ecode1 = SWIG_AsVal_int(obj0, &val1);
54232 if (!SWIG_IsOK(ecode1)) {
54233 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
54234 }
54235 arg1 = static_cast< int >(val1);
54236 }
54237 if (obj1) {
54238 ecode2 = SWIG_AsVal_int(obj1, &val2);
54239 if (!SWIG_IsOK(ecode2)) {
54240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
54241 }
54242 arg2 = static_cast< int >(val2);
54243 }
54244 {
54245 PyThreadState* __tstate = wxPyBeginAllowThreads();
54246 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
54247 wxPyEndAllowThreads(__tstate);
54248 if (PyErr_Occurred()) SWIG_fail;
54249 }
54250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
54251 return resultobj;
54252 fail:
54253 return NULL;
54254 }
54255
54256
54257 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54258 PyObject *resultobj = 0;
54259 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54260 void *argp1 = 0 ;
54261 int res1 = 0 ;
54262 PyObject *swig_obj[1] ;
54263
54264 if (!args) SWIG_fail;
54265 swig_obj[0] = args;
54266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
54267 if (!SWIG_IsOK(res1)) {
54268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54269 }
54270 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54271 {
54272 PyThreadState* __tstate = wxPyBeginAllowThreads();
54273 delete arg1;
54274
54275 wxPyEndAllowThreads(__tstate);
54276 if (PyErr_Occurred()) SWIG_fail;
54277 }
54278 resultobj = SWIG_Py_Void();
54279 return resultobj;
54280 fail:
54281 return NULL;
54282 }
54283
54284
54285 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54286 PyObject *resultobj = 0;
54287 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54288 int result;
54289 void *argp1 = 0 ;
54290 int res1 = 0 ;
54291 PyObject *swig_obj[1] ;
54292
54293 if (!args) SWIG_fail;
54294 swig_obj[0] = args;
54295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54296 if (!SWIG_IsOK(res1)) {
54297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
54298 }
54299 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54300 {
54301 PyThreadState* __tstate = wxPyBeginAllowThreads();
54302 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
54303 wxPyEndAllowThreads(__tstate);
54304 if (PyErr_Occurred()) SWIG_fail;
54305 }
54306 resultobj = SWIG_From_int(static_cast< int >(result));
54307 return resultobj;
54308 fail:
54309 return NULL;
54310 }
54311
54312
54313 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54314 PyObject *resultobj = 0;
54315 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54316 int result;
54317 void *argp1 = 0 ;
54318 int res1 = 0 ;
54319 PyObject *swig_obj[1] ;
54320
54321 if (!args) SWIG_fail;
54322 swig_obj[0] = args;
54323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54324 if (!SWIG_IsOK(res1)) {
54325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
54326 }
54327 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54328 {
54329 PyThreadState* __tstate = wxPyBeginAllowThreads();
54330 result = (int)((wxGBSpan const *)arg1)->GetColspan();
54331 wxPyEndAllowThreads(__tstate);
54332 if (PyErr_Occurred()) SWIG_fail;
54333 }
54334 resultobj = SWIG_From_int(static_cast< int >(result));
54335 return resultobj;
54336 fail:
54337 return NULL;
54338 }
54339
54340
54341 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54342 PyObject *resultobj = 0;
54343 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54344 int arg2 ;
54345 void *argp1 = 0 ;
54346 int res1 = 0 ;
54347 int val2 ;
54348 int ecode2 = 0 ;
54349 PyObject * obj0 = 0 ;
54350 PyObject * obj1 = 0 ;
54351 char * kwnames[] = {
54352 (char *) "self",(char *) "rowspan", NULL
54353 };
54354
54355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
54356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54357 if (!SWIG_IsOK(res1)) {
54358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54359 }
54360 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54361 ecode2 = SWIG_AsVal_int(obj1, &val2);
54362 if (!SWIG_IsOK(ecode2)) {
54363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
54364 }
54365 arg2 = static_cast< int >(val2);
54366 {
54367 PyThreadState* __tstate = wxPyBeginAllowThreads();
54368 (arg1)->SetRowspan(arg2);
54369 wxPyEndAllowThreads(__tstate);
54370 if (PyErr_Occurred()) SWIG_fail;
54371 }
54372 resultobj = SWIG_Py_Void();
54373 return resultobj;
54374 fail:
54375 return NULL;
54376 }
54377
54378
54379 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54380 PyObject *resultobj = 0;
54381 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54382 int arg2 ;
54383 void *argp1 = 0 ;
54384 int res1 = 0 ;
54385 int val2 ;
54386 int ecode2 = 0 ;
54387 PyObject * obj0 = 0 ;
54388 PyObject * obj1 = 0 ;
54389 char * kwnames[] = {
54390 (char *) "self",(char *) "colspan", NULL
54391 };
54392
54393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
54394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54395 if (!SWIG_IsOK(res1)) {
54396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54397 }
54398 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54399 ecode2 = SWIG_AsVal_int(obj1, &val2);
54400 if (!SWIG_IsOK(ecode2)) {
54401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
54402 }
54403 arg2 = static_cast< int >(val2);
54404 {
54405 PyThreadState* __tstate = wxPyBeginAllowThreads();
54406 (arg1)->SetColspan(arg2);
54407 wxPyEndAllowThreads(__tstate);
54408 if (PyErr_Occurred()) SWIG_fail;
54409 }
54410 resultobj = SWIG_Py_Void();
54411 return resultobj;
54412 fail:
54413 return NULL;
54414 }
54415
54416
54417 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54418 PyObject *resultobj = 0;
54419 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54420 PyObject *arg2 = (PyObject *) 0 ;
54421 bool result;
54422 void *argp1 = 0 ;
54423 int res1 = 0 ;
54424 PyObject * obj0 = 0 ;
54425 PyObject * obj1 = 0 ;
54426 char * kwnames[] = {
54427 (char *) "self",(char *) "other", NULL
54428 };
54429
54430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
54431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54432 if (!SWIG_IsOK(res1)) {
54433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54434 }
54435 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54436 arg2 = obj1;
54437 {
54438 result = (bool)wxGBSpan___eq__(arg1,arg2);
54439 if (PyErr_Occurred()) SWIG_fail;
54440 }
54441 {
54442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54443 }
54444 return resultobj;
54445 fail:
54446 return NULL;
54447 }
54448
54449
54450 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54451 PyObject *resultobj = 0;
54452 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54453 PyObject *arg2 = (PyObject *) 0 ;
54454 bool result;
54455 void *argp1 = 0 ;
54456 int res1 = 0 ;
54457 PyObject * obj0 = 0 ;
54458 PyObject * obj1 = 0 ;
54459 char * kwnames[] = {
54460 (char *) "self",(char *) "other", NULL
54461 };
54462
54463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
54464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54465 if (!SWIG_IsOK(res1)) {
54466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54467 }
54468 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54469 arg2 = obj1;
54470 {
54471 result = (bool)wxGBSpan___ne__(arg1,arg2);
54472 if (PyErr_Occurred()) SWIG_fail;
54473 }
54474 {
54475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54476 }
54477 return resultobj;
54478 fail:
54479 return NULL;
54480 }
54481
54482
54483 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54484 PyObject *resultobj = 0;
54485 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54486 int arg2 = (int) 1 ;
54487 int arg3 = (int) 1 ;
54488 void *argp1 = 0 ;
54489 int res1 = 0 ;
54490 int val2 ;
54491 int ecode2 = 0 ;
54492 int val3 ;
54493 int ecode3 = 0 ;
54494 PyObject * obj0 = 0 ;
54495 PyObject * obj1 = 0 ;
54496 PyObject * obj2 = 0 ;
54497 char * kwnames[] = {
54498 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
54499 };
54500
54501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54503 if (!SWIG_IsOK(res1)) {
54504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54505 }
54506 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54507 if (obj1) {
54508 ecode2 = SWIG_AsVal_int(obj1, &val2);
54509 if (!SWIG_IsOK(ecode2)) {
54510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
54511 }
54512 arg2 = static_cast< int >(val2);
54513 }
54514 if (obj2) {
54515 ecode3 = SWIG_AsVal_int(obj2, &val3);
54516 if (!SWIG_IsOK(ecode3)) {
54517 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
54518 }
54519 arg3 = static_cast< int >(val3);
54520 }
54521 {
54522 PyThreadState* __tstate = wxPyBeginAllowThreads();
54523 wxGBSpan_Set(arg1,arg2,arg3);
54524 wxPyEndAllowThreads(__tstate);
54525 if (PyErr_Occurred()) SWIG_fail;
54526 }
54527 resultobj = SWIG_Py_Void();
54528 return resultobj;
54529 fail:
54530 return NULL;
54531 }
54532
54533
54534 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54535 PyObject *resultobj = 0;
54536 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54537 PyObject *result = 0 ;
54538 void *argp1 = 0 ;
54539 int res1 = 0 ;
54540 PyObject *swig_obj[1] ;
54541
54542 if (!args) SWIG_fail;
54543 swig_obj[0] = args;
54544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54545 if (!SWIG_IsOK(res1)) {
54546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54547 }
54548 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54549 {
54550 PyThreadState* __tstate = wxPyBeginAllowThreads();
54551 result = (PyObject *)wxGBSpan_Get(arg1);
54552 wxPyEndAllowThreads(__tstate);
54553 if (PyErr_Occurred()) SWIG_fail;
54554 }
54555 resultobj = result;
54556 return resultobj;
54557 fail:
54558 return NULL;
54559 }
54560
54561
54562 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54563 PyObject *obj;
54564 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54565 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
54566 return SWIG_Py_Void();
54567 }
54568
54569 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54570 return SWIG_Python_InitShadowInstance(args);
54571 }
54572
54573 SWIGINTERN int DefaultSpan_set(PyObject *) {
54574 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
54575 return 1;
54576 }
54577
54578
54579 SWIGINTERN PyObject *DefaultSpan_get(void) {
54580 PyObject *pyobj = 0;
54581
54582 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
54583 return pyobj;
54584 }
54585
54586
54587 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54588 PyObject *resultobj = 0;
54589 wxGBSizerItem *result = 0 ;
54590
54591 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
54592 {
54593 PyThreadState* __tstate = wxPyBeginAllowThreads();
54594 result = (wxGBSizerItem *)new wxGBSizerItem();
54595 wxPyEndAllowThreads(__tstate);
54596 if (PyErr_Occurred()) SWIG_fail;
54597 }
54598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
54599 return resultobj;
54600 fail:
54601 return NULL;
54602 }
54603
54604
54605 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54606 PyObject *resultobj = 0;
54607 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54608 void *argp1 = 0 ;
54609 int res1 = 0 ;
54610 PyObject *swig_obj[1] ;
54611
54612 if (!args) SWIG_fail;
54613 swig_obj[0] = args;
54614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
54615 if (!SWIG_IsOK(res1)) {
54616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
54617 }
54618 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54619 {
54620 PyThreadState* __tstate = wxPyBeginAllowThreads();
54621 delete arg1;
54622
54623 wxPyEndAllowThreads(__tstate);
54624 if (PyErr_Occurred()) SWIG_fail;
54625 }
54626 resultobj = SWIG_Py_Void();
54627 return resultobj;
54628 fail:
54629 return NULL;
54630 }
54631
54632
54633 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54634 PyObject *resultobj = 0;
54635 wxWindow *arg1 = (wxWindow *) 0 ;
54636 wxGBPosition *arg2 = 0 ;
54637 wxGBSpan *arg3 = 0 ;
54638 int arg4 ;
54639 int arg5 ;
54640 PyObject *arg6 = (PyObject *) NULL ;
54641 wxGBSizerItem *result = 0 ;
54642 void *argp1 = 0 ;
54643 int res1 = 0 ;
54644 wxGBPosition temp2 ;
54645 wxGBSpan temp3 ;
54646 int val4 ;
54647 int ecode4 = 0 ;
54648 int val5 ;
54649 int ecode5 = 0 ;
54650 PyObject * obj0 = 0 ;
54651 PyObject * obj1 = 0 ;
54652 PyObject * obj2 = 0 ;
54653 PyObject * obj3 = 0 ;
54654 PyObject * obj4 = 0 ;
54655 PyObject * obj5 = 0 ;
54656 char * kwnames[] = {
54657 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
54658 };
54659
54660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
54661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
54662 if (!SWIG_IsOK(res1)) {
54663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
54664 }
54665 arg1 = reinterpret_cast< wxWindow * >(argp1);
54666 {
54667 arg2 = &temp2;
54668 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54669 }
54670 {
54671 arg3 = &temp3;
54672 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54673 }
54674 ecode4 = SWIG_AsVal_int(obj3, &val4);
54675 if (!SWIG_IsOK(ecode4)) {
54676 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
54677 }
54678 arg4 = static_cast< int >(val4);
54679 ecode5 = SWIG_AsVal_int(obj4, &val5);
54680 if (!SWIG_IsOK(ecode5)) {
54681 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
54682 }
54683 arg5 = static_cast< int >(val5);
54684 if (obj5) {
54685 arg6 = obj5;
54686 }
54687 {
54688 PyThreadState* __tstate = wxPyBeginAllowThreads();
54689 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
54690 wxPyEndAllowThreads(__tstate);
54691 if (PyErr_Occurred()) SWIG_fail;
54692 }
54693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
54694 return resultobj;
54695 fail:
54696 return NULL;
54697 }
54698
54699
54700 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54701 PyObject *resultobj = 0;
54702 wxSizer *arg1 = (wxSizer *) 0 ;
54703 wxGBPosition *arg2 = 0 ;
54704 wxGBSpan *arg3 = 0 ;
54705 int arg4 ;
54706 int arg5 ;
54707 PyObject *arg6 = (PyObject *) NULL ;
54708 wxGBSizerItem *result = 0 ;
54709 int res1 = 0 ;
54710 wxGBPosition temp2 ;
54711 wxGBSpan temp3 ;
54712 int val4 ;
54713 int ecode4 = 0 ;
54714 int val5 ;
54715 int ecode5 = 0 ;
54716 PyObject * obj0 = 0 ;
54717 PyObject * obj1 = 0 ;
54718 PyObject * obj2 = 0 ;
54719 PyObject * obj3 = 0 ;
54720 PyObject * obj4 = 0 ;
54721 PyObject * obj5 = 0 ;
54722 char * kwnames[] = {
54723 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
54724 };
54725
54726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
54727 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
54728 if (!SWIG_IsOK(res1)) {
54729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
54730 }
54731 {
54732 arg2 = &temp2;
54733 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54734 }
54735 {
54736 arg3 = &temp3;
54737 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54738 }
54739 ecode4 = SWIG_AsVal_int(obj3, &val4);
54740 if (!SWIG_IsOK(ecode4)) {
54741 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
54742 }
54743 arg4 = static_cast< int >(val4);
54744 ecode5 = SWIG_AsVal_int(obj4, &val5);
54745 if (!SWIG_IsOK(ecode5)) {
54746 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
54747 }
54748 arg5 = static_cast< int >(val5);
54749 if (obj5) {
54750 arg6 = obj5;
54751 }
54752 {
54753 PyThreadState* __tstate = wxPyBeginAllowThreads();
54754 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
54755 wxPyEndAllowThreads(__tstate);
54756 if (PyErr_Occurred()) SWIG_fail;
54757 }
54758 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
54759 return resultobj;
54760 fail:
54761 return NULL;
54762 }
54763
54764
54765 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54766 PyObject *resultobj = 0;
54767 int arg1 ;
54768 int arg2 ;
54769 wxGBPosition *arg3 = 0 ;
54770 wxGBSpan *arg4 = 0 ;
54771 int arg5 ;
54772 int arg6 ;
54773 PyObject *arg7 = (PyObject *) NULL ;
54774 wxGBSizerItem *result = 0 ;
54775 int val1 ;
54776 int ecode1 = 0 ;
54777 int val2 ;
54778 int ecode2 = 0 ;
54779 wxGBPosition temp3 ;
54780 wxGBSpan temp4 ;
54781 int val5 ;
54782 int ecode5 = 0 ;
54783 int val6 ;
54784 int ecode6 = 0 ;
54785 PyObject * obj0 = 0 ;
54786 PyObject * obj1 = 0 ;
54787 PyObject * obj2 = 0 ;
54788 PyObject * obj3 = 0 ;
54789 PyObject * obj4 = 0 ;
54790 PyObject * obj5 = 0 ;
54791 PyObject * obj6 = 0 ;
54792 char * kwnames[] = {
54793 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
54794 };
54795
54796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
54797 ecode1 = SWIG_AsVal_int(obj0, &val1);
54798 if (!SWIG_IsOK(ecode1)) {
54799 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
54800 }
54801 arg1 = static_cast< int >(val1);
54802 ecode2 = SWIG_AsVal_int(obj1, &val2);
54803 if (!SWIG_IsOK(ecode2)) {
54804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
54805 }
54806 arg2 = static_cast< int >(val2);
54807 {
54808 arg3 = &temp3;
54809 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
54810 }
54811 {
54812 arg4 = &temp4;
54813 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
54814 }
54815 ecode5 = SWIG_AsVal_int(obj4, &val5);
54816 if (!SWIG_IsOK(ecode5)) {
54817 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
54818 }
54819 arg5 = static_cast< int >(val5);
54820 ecode6 = SWIG_AsVal_int(obj5, &val6);
54821 if (!SWIG_IsOK(ecode6)) {
54822 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
54823 }
54824 arg6 = static_cast< int >(val6);
54825 if (obj6) {
54826 arg7 = obj6;
54827 }
54828 {
54829 PyThreadState* __tstate = wxPyBeginAllowThreads();
54830 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
54831 wxPyEndAllowThreads(__tstate);
54832 if (PyErr_Occurred()) SWIG_fail;
54833 }
54834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
54835 return resultobj;
54836 fail:
54837 return NULL;
54838 }
54839
54840
54841 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54842 PyObject *resultobj = 0;
54843 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54844 wxGBPosition result;
54845 void *argp1 = 0 ;
54846 int res1 = 0 ;
54847 PyObject *swig_obj[1] ;
54848
54849 if (!args) SWIG_fail;
54850 swig_obj[0] = args;
54851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54852 if (!SWIG_IsOK(res1)) {
54853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
54854 }
54855 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54856 {
54857 PyThreadState* __tstate = wxPyBeginAllowThreads();
54858 result = ((wxGBSizerItem const *)arg1)->GetPos();
54859 wxPyEndAllowThreads(__tstate);
54860 if (PyErr_Occurred()) SWIG_fail;
54861 }
54862 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54863 return resultobj;
54864 fail:
54865 return NULL;
54866 }
54867
54868
54869 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54870 PyObject *resultobj = 0;
54871 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54872 wxGBSpan result;
54873 void *argp1 = 0 ;
54874 int res1 = 0 ;
54875 PyObject *swig_obj[1] ;
54876
54877 if (!args) SWIG_fail;
54878 swig_obj[0] = args;
54879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54880 if (!SWIG_IsOK(res1)) {
54881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
54882 }
54883 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54884 {
54885 PyThreadState* __tstate = wxPyBeginAllowThreads();
54886 result = ((wxGBSizerItem const *)arg1)->GetSpan();
54887 wxPyEndAllowThreads(__tstate);
54888 if (PyErr_Occurred()) SWIG_fail;
54889 }
54890 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54891 return resultobj;
54892 fail:
54893 return NULL;
54894 }
54895
54896
54897 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54898 PyObject *resultobj = 0;
54899 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54900 wxGBPosition *arg2 = 0 ;
54901 bool result;
54902 void *argp1 = 0 ;
54903 int res1 = 0 ;
54904 wxGBPosition temp2 ;
54905 PyObject * obj0 = 0 ;
54906 PyObject * obj1 = 0 ;
54907 char * kwnames[] = {
54908 (char *) "self",(char *) "pos", NULL
54909 };
54910
54911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
54912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54913 if (!SWIG_IsOK(res1)) {
54914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
54915 }
54916 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54917 {
54918 arg2 = &temp2;
54919 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54920 }
54921 {
54922 PyThreadState* __tstate = wxPyBeginAllowThreads();
54923 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
54924 wxPyEndAllowThreads(__tstate);
54925 if (PyErr_Occurred()) SWIG_fail;
54926 }
54927 {
54928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54929 }
54930 return resultobj;
54931 fail:
54932 return NULL;
54933 }
54934
54935
54936 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54937 PyObject *resultobj = 0;
54938 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54939 wxGBSpan *arg2 = 0 ;
54940 bool result;
54941 void *argp1 = 0 ;
54942 int res1 = 0 ;
54943 wxGBSpan temp2 ;
54944 PyObject * obj0 = 0 ;
54945 PyObject * obj1 = 0 ;
54946 char * kwnames[] = {
54947 (char *) "self",(char *) "span", NULL
54948 };
54949
54950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
54951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54952 if (!SWIG_IsOK(res1)) {
54953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
54954 }
54955 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54956 {
54957 arg2 = &temp2;
54958 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
54959 }
54960 {
54961 PyThreadState* __tstate = wxPyBeginAllowThreads();
54962 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
54963 wxPyEndAllowThreads(__tstate);
54964 if (PyErr_Occurred()) SWIG_fail;
54965 }
54966 {
54967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54968 }
54969 return resultobj;
54970 fail:
54971 return NULL;
54972 }
54973
54974
54975 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54976 PyObject *resultobj = 0;
54977 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54978 wxGBSizerItem *arg2 = 0 ;
54979 bool result;
54980 void *argp1 = 0 ;
54981 int res1 = 0 ;
54982 void *argp2 = 0 ;
54983 int res2 = 0 ;
54984 PyObject * obj0 = 0 ;
54985 PyObject * obj1 = 0 ;
54986 char * kwnames[] = {
54987 (char *) "self",(char *) "other", NULL
54988 };
54989
54990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
54991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54992 if (!SWIG_IsOK(res1)) {
54993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
54994 }
54995 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54996 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
54997 if (!SWIG_IsOK(res2)) {
54998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
54999 }
55000 if (!argp2) {
55001 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
55002 }
55003 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
55004 {
55005 PyThreadState* __tstate = wxPyBeginAllowThreads();
55006 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
55007 wxPyEndAllowThreads(__tstate);
55008 if (PyErr_Occurred()) SWIG_fail;
55009 }
55010 {
55011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55012 }
55013 return resultobj;
55014 fail:
55015 return NULL;
55016 }
55017
55018
55019 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55020 PyObject *resultobj = 0;
55021 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55022 wxGBPosition *arg2 = 0 ;
55023 wxGBSpan *arg3 = 0 ;
55024 bool result;
55025 void *argp1 = 0 ;
55026 int res1 = 0 ;
55027 wxGBPosition temp2 ;
55028 wxGBSpan temp3 ;
55029 PyObject * obj0 = 0 ;
55030 PyObject * obj1 = 0 ;
55031 PyObject * obj2 = 0 ;
55032 char * kwnames[] = {
55033 (char *) "self",(char *) "pos",(char *) "span", NULL
55034 };
55035
55036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55038 if (!SWIG_IsOK(res1)) {
55039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55040 }
55041 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55042 {
55043 arg2 = &temp2;
55044 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55045 }
55046 {
55047 arg3 = &temp3;
55048 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55049 }
55050 {
55051 PyThreadState* __tstate = wxPyBeginAllowThreads();
55052 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
55053 wxPyEndAllowThreads(__tstate);
55054 if (PyErr_Occurred()) SWIG_fail;
55055 }
55056 {
55057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55058 }
55059 return resultobj;
55060 fail:
55061 return NULL;
55062 }
55063
55064
55065 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55066 PyObject *resultobj = 0;
55067 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55068 wxGBPosition result;
55069 void *argp1 = 0 ;
55070 int res1 = 0 ;
55071 PyObject *swig_obj[1] ;
55072
55073 if (!args) SWIG_fail;
55074 swig_obj[0] = args;
55075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55076 if (!SWIG_IsOK(res1)) {
55077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55078 }
55079 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55080 {
55081 PyThreadState* __tstate = wxPyBeginAllowThreads();
55082 result = wxGBSizerItem_GetEndPos(arg1);
55083 wxPyEndAllowThreads(__tstate);
55084 if (PyErr_Occurred()) SWIG_fail;
55085 }
55086 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55087 return resultobj;
55088 fail:
55089 return NULL;
55090 }
55091
55092
55093 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55094 PyObject *resultobj = 0;
55095 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55096 wxGridBagSizer *result = 0 ;
55097 void *argp1 = 0 ;
55098 int res1 = 0 ;
55099 PyObject *swig_obj[1] ;
55100
55101 if (!args) SWIG_fail;
55102 swig_obj[0] = args;
55103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55104 if (!SWIG_IsOK(res1)) {
55105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55106 }
55107 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55108 {
55109 PyThreadState* __tstate = wxPyBeginAllowThreads();
55110 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
55111 wxPyEndAllowThreads(__tstate);
55112 if (PyErr_Occurred()) SWIG_fail;
55113 }
55114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55115 return resultobj;
55116 fail:
55117 return NULL;
55118 }
55119
55120
55121 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55122 PyObject *resultobj = 0;
55123 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55124 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
55125 void *argp1 = 0 ;
55126 int res1 = 0 ;
55127 void *argp2 = 0 ;
55128 int res2 = 0 ;
55129 PyObject * obj0 = 0 ;
55130 PyObject * obj1 = 0 ;
55131 char * kwnames[] = {
55132 (char *) "self",(char *) "sizer", NULL
55133 };
55134
55135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55137 if (!SWIG_IsOK(res1)) {
55138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55139 }
55140 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55141 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55142 if (!SWIG_IsOK(res2)) {
55143 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
55144 }
55145 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
55146 {
55147 PyThreadState* __tstate = wxPyBeginAllowThreads();
55148 (arg1)->SetGBSizer(arg2);
55149 wxPyEndAllowThreads(__tstate);
55150 if (PyErr_Occurred()) SWIG_fail;
55151 }
55152 resultobj = SWIG_Py_Void();
55153 return resultobj;
55154 fail:
55155 return NULL;
55156 }
55157
55158
55159 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55160 PyObject *obj;
55161 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55162 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
55163 return SWIG_Py_Void();
55164 }
55165
55166 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55167 return SWIG_Python_InitShadowInstance(args);
55168 }
55169
55170 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55171 PyObject *resultobj = 0;
55172 int arg1 = (int) 0 ;
55173 int arg2 = (int) 0 ;
55174 wxGridBagSizer *result = 0 ;
55175 int val1 ;
55176 int ecode1 = 0 ;
55177 int val2 ;
55178 int ecode2 = 0 ;
55179 PyObject * obj0 = 0 ;
55180 PyObject * obj1 = 0 ;
55181 char * kwnames[] = {
55182 (char *) "vgap",(char *) "hgap", NULL
55183 };
55184
55185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55186 if (obj0) {
55187 ecode1 = SWIG_AsVal_int(obj0, &val1);
55188 if (!SWIG_IsOK(ecode1)) {
55189 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
55190 }
55191 arg1 = static_cast< int >(val1);
55192 }
55193 if (obj1) {
55194 ecode2 = SWIG_AsVal_int(obj1, &val2);
55195 if (!SWIG_IsOK(ecode2)) {
55196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
55197 }
55198 arg2 = static_cast< int >(val2);
55199 }
55200 {
55201 PyThreadState* __tstate = wxPyBeginAllowThreads();
55202 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
55203 wxPyEndAllowThreads(__tstate);
55204 if (PyErr_Occurred()) SWIG_fail;
55205 }
55206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
55207 return resultobj;
55208 fail:
55209 return NULL;
55210 }
55211
55212
55213 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55214 PyObject *resultobj = 0;
55215 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55216 PyObject *arg2 = (PyObject *) 0 ;
55217 wxGBPosition *arg3 = 0 ;
55218 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
55219 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
55220 int arg5 = (int) 0 ;
55221 int arg6 = (int) 0 ;
55222 PyObject *arg7 = (PyObject *) NULL ;
55223 wxGBSizerItem *result = 0 ;
55224 void *argp1 = 0 ;
55225 int res1 = 0 ;
55226 wxGBPosition temp3 ;
55227 wxGBSpan temp4 ;
55228 int val5 ;
55229 int ecode5 = 0 ;
55230 int val6 ;
55231 int ecode6 = 0 ;
55232 PyObject * obj0 = 0 ;
55233 PyObject * obj1 = 0 ;
55234 PyObject * obj2 = 0 ;
55235 PyObject * obj3 = 0 ;
55236 PyObject * obj4 = 0 ;
55237 PyObject * obj5 = 0 ;
55238 PyObject * obj6 = 0 ;
55239 char * kwnames[] = {
55240 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55241 };
55242
55243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
55244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55245 if (!SWIG_IsOK(res1)) {
55246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55247 }
55248 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55249 arg2 = obj1;
55250 {
55251 arg3 = &temp3;
55252 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
55253 }
55254 if (obj3) {
55255 {
55256 arg4 = &temp4;
55257 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
55258 }
55259 }
55260 if (obj4) {
55261 ecode5 = SWIG_AsVal_int(obj4, &val5);
55262 if (!SWIG_IsOK(ecode5)) {
55263 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
55264 }
55265 arg5 = static_cast< int >(val5);
55266 }
55267 if (obj5) {
55268 ecode6 = SWIG_AsVal_int(obj5, &val6);
55269 if (!SWIG_IsOK(ecode6)) {
55270 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
55271 }
55272 arg6 = static_cast< int >(val6);
55273 }
55274 if (obj6) {
55275 arg7 = obj6;
55276 }
55277 {
55278 PyThreadState* __tstate = wxPyBeginAllowThreads();
55279 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
55280 wxPyEndAllowThreads(__tstate);
55281 if (PyErr_Occurred()) SWIG_fail;
55282 }
55283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55284 return resultobj;
55285 fail:
55286 return NULL;
55287 }
55288
55289
55290 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55291 PyObject *resultobj = 0;
55292 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55293 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
55294 wxGBSizerItem *result = 0 ;
55295 void *argp1 = 0 ;
55296 int res1 = 0 ;
55297 int res2 = 0 ;
55298 PyObject * obj0 = 0 ;
55299 PyObject * obj1 = 0 ;
55300 char * kwnames[] = {
55301 (char *) "self",(char *) "item", NULL
55302 };
55303
55304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
55305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55306 if (!SWIG_IsOK(res1)) {
55307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55308 }
55309 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55310 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
55311 if (!SWIG_IsOK(res2)) {
55312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
55313 }
55314 {
55315 PyThreadState* __tstate = wxPyBeginAllowThreads();
55316 result = (wxGBSizerItem *)(arg1)->Add(arg2);
55317 wxPyEndAllowThreads(__tstate);
55318 if (PyErr_Occurred()) SWIG_fail;
55319 }
55320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55321 return resultobj;
55322 fail:
55323 return NULL;
55324 }
55325
55326
55327 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55328 PyObject *resultobj = 0;
55329 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55330 int arg2 ;
55331 int arg3 ;
55332 wxSize result;
55333 void *argp1 = 0 ;
55334 int res1 = 0 ;
55335 int val2 ;
55336 int ecode2 = 0 ;
55337 int val3 ;
55338 int ecode3 = 0 ;
55339 PyObject * obj0 = 0 ;
55340 PyObject * obj1 = 0 ;
55341 PyObject * obj2 = 0 ;
55342 char * kwnames[] = {
55343 (char *) "self",(char *) "row",(char *) "col", NULL
55344 };
55345
55346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55348 if (!SWIG_IsOK(res1)) {
55349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
55350 }
55351 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55352 ecode2 = SWIG_AsVal_int(obj1, &val2);
55353 if (!SWIG_IsOK(ecode2)) {
55354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
55355 }
55356 arg2 = static_cast< int >(val2);
55357 ecode3 = SWIG_AsVal_int(obj2, &val3);
55358 if (!SWIG_IsOK(ecode3)) {
55359 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
55360 }
55361 arg3 = static_cast< int >(val3);
55362 {
55363 PyThreadState* __tstate = wxPyBeginAllowThreads();
55364 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
55365 wxPyEndAllowThreads(__tstate);
55366 if (PyErr_Occurred()) SWIG_fail;
55367 }
55368 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
55369 return resultobj;
55370 fail:
55371 return NULL;
55372 }
55373
55374
55375 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55376 PyObject *resultobj = 0;
55377 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55378 wxSize result;
55379 void *argp1 = 0 ;
55380 int res1 = 0 ;
55381 PyObject *swig_obj[1] ;
55382
55383 if (!args) SWIG_fail;
55384 swig_obj[0] = args;
55385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55386 if (!SWIG_IsOK(res1)) {
55387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
55388 }
55389 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55390 {
55391 PyThreadState* __tstate = wxPyBeginAllowThreads();
55392 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
55393 wxPyEndAllowThreads(__tstate);
55394 if (PyErr_Occurred()) SWIG_fail;
55395 }
55396 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
55397 return resultobj;
55398 fail:
55399 return NULL;
55400 }
55401
55402
55403 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55404 PyObject *resultobj = 0;
55405 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55406 wxSize *arg2 = 0 ;
55407 void *argp1 = 0 ;
55408 int res1 = 0 ;
55409 wxSize temp2 ;
55410 PyObject * obj0 = 0 ;
55411 PyObject * obj1 = 0 ;
55412 char * kwnames[] = {
55413 (char *) "self",(char *) "sz", NULL
55414 };
55415
55416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
55417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55418 if (!SWIG_IsOK(res1)) {
55419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55420 }
55421 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55422 {
55423 arg2 = &temp2;
55424 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
55425 }
55426 {
55427 PyThreadState* __tstate = wxPyBeginAllowThreads();
55428 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
55429 wxPyEndAllowThreads(__tstate);
55430 if (PyErr_Occurred()) SWIG_fail;
55431 }
55432 resultobj = SWIG_Py_Void();
55433 return resultobj;
55434 fail:
55435 return NULL;
55436 }
55437
55438
55439 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55440 PyObject *resultobj = 0;
55441 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55442 wxWindow *arg2 = (wxWindow *) 0 ;
55443 wxGBPosition result;
55444 void *argp1 = 0 ;
55445 int res1 = 0 ;
55446 void *argp2 = 0 ;
55447 int res2 = 0 ;
55448
55449 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55451 if (!SWIG_IsOK(res1)) {
55452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55453 }
55454 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55455 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55456 if (!SWIG_IsOK(res2)) {
55457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
55458 }
55459 arg2 = reinterpret_cast< wxWindow * >(argp2);
55460 {
55461 PyThreadState* __tstate = wxPyBeginAllowThreads();
55462 result = (arg1)->GetItemPosition(arg2);
55463 wxPyEndAllowThreads(__tstate);
55464 if (PyErr_Occurred()) SWIG_fail;
55465 }
55466 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55467 return resultobj;
55468 fail:
55469 return NULL;
55470 }
55471
55472
55473 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55474 PyObject *resultobj = 0;
55475 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55476 wxSizer *arg2 = (wxSizer *) 0 ;
55477 wxGBPosition result;
55478 void *argp1 = 0 ;
55479 int res1 = 0 ;
55480 void *argp2 = 0 ;
55481 int res2 = 0 ;
55482
55483 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55485 if (!SWIG_IsOK(res1)) {
55486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55487 }
55488 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55489 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
55490 if (!SWIG_IsOK(res2)) {
55491 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
55492 }
55493 arg2 = reinterpret_cast< wxSizer * >(argp2);
55494 {
55495 PyThreadState* __tstate = wxPyBeginAllowThreads();
55496 result = (arg1)->GetItemPosition(arg2);
55497 wxPyEndAllowThreads(__tstate);
55498 if (PyErr_Occurred()) SWIG_fail;
55499 }
55500 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55501 return resultobj;
55502 fail:
55503 return NULL;
55504 }
55505
55506
55507 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55508 PyObject *resultobj = 0;
55509 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55510 size_t arg2 ;
55511 wxGBPosition result;
55512 void *argp1 = 0 ;
55513 int res1 = 0 ;
55514 size_t val2 ;
55515 int ecode2 = 0 ;
55516
55517 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55519 if (!SWIG_IsOK(res1)) {
55520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55521 }
55522 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55523 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
55524 if (!SWIG_IsOK(ecode2)) {
55525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
55526 }
55527 arg2 = static_cast< size_t >(val2);
55528 {
55529 PyThreadState* __tstate = wxPyBeginAllowThreads();
55530 result = (arg1)->GetItemPosition(arg2);
55531 wxPyEndAllowThreads(__tstate);
55532 if (PyErr_Occurred()) SWIG_fail;
55533 }
55534 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55535 return resultobj;
55536 fail:
55537 return NULL;
55538 }
55539
55540
55541 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
55542 int argc;
55543 PyObject *argv[3];
55544
55545 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
55546 --argc;
55547 if (argc == 2) {
55548 int _v = 0;
55549 {
55550 void *vptr = 0;
55551 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
55552 _v = SWIG_CheckState(res);
55553 }
55554 if (!_v) goto check_1;
55555 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
55556 }
55557 check_1:
55558
55559 if (argc == 2) {
55560 int _v = 0;
55561 {
55562 void *vptr = 0;
55563 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
55564 _v = SWIG_CheckState(res);
55565 }
55566 if (!_v) goto check_2;
55567 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
55568 }
55569 check_2:
55570
55571 if (argc == 2) {
55572 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
55573 }
55574
55575 fail:
55576 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
55577 return NULL;
55578 }
55579
55580
55581 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55582 PyObject *resultobj = 0;
55583 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55584 wxWindow *arg2 = (wxWindow *) 0 ;
55585 wxGBPosition *arg3 = 0 ;
55586 bool result;
55587 void *argp1 = 0 ;
55588 int res1 = 0 ;
55589 void *argp2 = 0 ;
55590 int res2 = 0 ;
55591 wxGBPosition temp3 ;
55592
55593 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55595 if (!SWIG_IsOK(res1)) {
55596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55597 }
55598 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55599 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55600 if (!SWIG_IsOK(res2)) {
55601 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
55602 }
55603 arg2 = reinterpret_cast< wxWindow * >(argp2);
55604 {
55605 arg3 = &temp3;
55606 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
55607 }
55608 {
55609 PyThreadState* __tstate = wxPyBeginAllowThreads();
55610 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
55611 wxPyEndAllowThreads(__tstate);
55612 if (PyErr_Occurred()) SWIG_fail;
55613 }
55614 {
55615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55616 }
55617 return resultobj;
55618 fail:
55619 return NULL;
55620 }
55621
55622
55623 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55624 PyObject *resultobj = 0;
55625 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55626 wxSizer *arg2 = (wxSizer *) 0 ;
55627 wxGBPosition *arg3 = 0 ;
55628 bool result;
55629 void *argp1 = 0 ;
55630 int res1 = 0 ;
55631 void *argp2 = 0 ;
55632 int res2 = 0 ;
55633 wxGBPosition temp3 ;
55634
55635 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55637 if (!SWIG_IsOK(res1)) {
55638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55639 }
55640 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55641 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
55642 if (!SWIG_IsOK(res2)) {
55643 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
55644 }
55645 arg2 = reinterpret_cast< wxSizer * >(argp2);
55646 {
55647 arg3 = &temp3;
55648 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
55649 }
55650 {
55651 PyThreadState* __tstate = wxPyBeginAllowThreads();
55652 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
55653 wxPyEndAllowThreads(__tstate);
55654 if (PyErr_Occurred()) SWIG_fail;
55655 }
55656 {
55657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55658 }
55659 return resultobj;
55660 fail:
55661 return NULL;
55662 }
55663
55664
55665 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55666 PyObject *resultobj = 0;
55667 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55668 size_t arg2 ;
55669 wxGBPosition *arg3 = 0 ;
55670 bool result;
55671 void *argp1 = 0 ;
55672 int res1 = 0 ;
55673 size_t val2 ;
55674 int ecode2 = 0 ;
55675 wxGBPosition temp3 ;
55676
55677 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55679 if (!SWIG_IsOK(res1)) {
55680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55681 }
55682 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55683 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
55684 if (!SWIG_IsOK(ecode2)) {
55685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
55686 }
55687 arg2 = static_cast< size_t >(val2);
55688 {
55689 arg3 = &temp3;
55690 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
55691 }
55692 {
55693 PyThreadState* __tstate = wxPyBeginAllowThreads();
55694 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
55695 wxPyEndAllowThreads(__tstate);
55696 if (PyErr_Occurred()) SWIG_fail;
55697 }
55698 {
55699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55700 }
55701 return resultobj;
55702 fail:
55703 return NULL;
55704 }
55705
55706
55707 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
55708 int argc;
55709 PyObject *argv[4];
55710
55711 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
55712 --argc;
55713 if (argc == 3) {
55714 int _v = 0;
55715 {
55716 void *vptr = 0;
55717 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
55718 _v = SWIG_CheckState(res);
55719 }
55720 if (!_v) goto check_1;
55721 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
55722 }
55723 check_1:
55724
55725 if (argc == 3) {
55726 int _v = 0;
55727 {
55728 void *vptr = 0;
55729 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
55730 _v = SWIG_CheckState(res);
55731 }
55732 if (!_v) goto check_2;
55733 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
55734 }
55735 check_2:
55736
55737 if (argc == 3) {
55738 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
55739 }
55740
55741 fail:
55742 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
55743 return NULL;
55744 }
55745
55746
55747 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55748 PyObject *resultobj = 0;
55749 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55750 wxWindow *arg2 = (wxWindow *) 0 ;
55751 wxGBSpan result;
55752 void *argp1 = 0 ;
55753 int res1 = 0 ;
55754 void *argp2 = 0 ;
55755 int res2 = 0 ;
55756
55757 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55759 if (!SWIG_IsOK(res1)) {
55760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55761 }
55762 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55763 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55764 if (!SWIG_IsOK(res2)) {
55765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
55766 }
55767 arg2 = reinterpret_cast< wxWindow * >(argp2);
55768 {
55769 PyThreadState* __tstate = wxPyBeginAllowThreads();
55770 result = (arg1)->GetItemSpan(arg2);
55771 wxPyEndAllowThreads(__tstate);
55772 if (PyErr_Occurred()) SWIG_fail;
55773 }
55774 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55775 return resultobj;
55776 fail:
55777 return NULL;
55778 }
55779
55780
55781 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55782 PyObject *resultobj = 0;
55783 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55784 wxSizer *arg2 = (wxSizer *) 0 ;
55785 wxGBSpan result;
55786 void *argp1 = 0 ;
55787 int res1 = 0 ;
55788 void *argp2 = 0 ;
55789 int res2 = 0 ;
55790
55791 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55793 if (!SWIG_IsOK(res1)) {
55794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55795 }
55796 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55797 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
55798 if (!SWIG_IsOK(res2)) {
55799 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
55800 }
55801 arg2 = reinterpret_cast< wxSizer * >(argp2);
55802 {
55803 PyThreadState* __tstate = wxPyBeginAllowThreads();
55804 result = (arg1)->GetItemSpan(arg2);
55805 wxPyEndAllowThreads(__tstate);
55806 if (PyErr_Occurred()) SWIG_fail;
55807 }
55808 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55809 return resultobj;
55810 fail:
55811 return NULL;
55812 }
55813
55814
55815 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55816 PyObject *resultobj = 0;
55817 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55818 size_t arg2 ;
55819 wxGBSpan result;
55820 void *argp1 = 0 ;
55821 int res1 = 0 ;
55822 size_t val2 ;
55823 int ecode2 = 0 ;
55824
55825 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55827 if (!SWIG_IsOK(res1)) {
55828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55829 }
55830 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55831 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
55832 if (!SWIG_IsOK(ecode2)) {
55833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
55834 }
55835 arg2 = static_cast< size_t >(val2);
55836 {
55837 PyThreadState* __tstate = wxPyBeginAllowThreads();
55838 result = (arg1)->GetItemSpan(arg2);
55839 wxPyEndAllowThreads(__tstate);
55840 if (PyErr_Occurred()) SWIG_fail;
55841 }
55842 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55843 return resultobj;
55844 fail:
55845 return NULL;
55846 }
55847
55848
55849 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
55850 int argc;
55851 PyObject *argv[3];
55852
55853 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
55854 --argc;
55855 if (argc == 2) {
55856 int _v = 0;
55857 {
55858 void *vptr = 0;
55859 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
55860 _v = SWIG_CheckState(res);
55861 }
55862 if (!_v) goto check_1;
55863 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
55864 }
55865 check_1:
55866
55867 if (argc == 2) {
55868 int _v = 0;
55869 {
55870 void *vptr = 0;
55871 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
55872 _v = SWIG_CheckState(res);
55873 }
55874 if (!_v) goto check_2;
55875 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
55876 }
55877 check_2:
55878
55879 if (argc == 2) {
55880 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
55881 }
55882
55883 fail:
55884 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
55885 return NULL;
55886 }
55887
55888
55889 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55890 PyObject *resultobj = 0;
55891 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55892 wxWindow *arg2 = (wxWindow *) 0 ;
55893 wxGBSpan *arg3 = 0 ;
55894 bool result;
55895 void *argp1 = 0 ;
55896 int res1 = 0 ;
55897 void *argp2 = 0 ;
55898 int res2 = 0 ;
55899 wxGBSpan temp3 ;
55900
55901 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55903 if (!SWIG_IsOK(res1)) {
55904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55905 }
55906 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55907 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55908 if (!SWIG_IsOK(res2)) {
55909 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
55910 }
55911 arg2 = reinterpret_cast< wxWindow * >(argp2);
55912 {
55913 arg3 = &temp3;
55914 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
55915 }
55916 {
55917 PyThreadState* __tstate = wxPyBeginAllowThreads();
55918 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
55919 wxPyEndAllowThreads(__tstate);
55920 if (PyErr_Occurred()) SWIG_fail;
55921 }
55922 {
55923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55924 }
55925 return resultobj;
55926 fail:
55927 return NULL;
55928 }
55929
55930
55931 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55932 PyObject *resultobj = 0;
55933 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55934 wxSizer *arg2 = (wxSizer *) 0 ;
55935 wxGBSpan *arg3 = 0 ;
55936 bool result;
55937 void *argp1 = 0 ;
55938 int res1 = 0 ;
55939 void *argp2 = 0 ;
55940 int res2 = 0 ;
55941 wxGBSpan temp3 ;
55942
55943 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55945 if (!SWIG_IsOK(res1)) {
55946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55947 }
55948 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55949 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
55950 if (!SWIG_IsOK(res2)) {
55951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
55952 }
55953 arg2 = reinterpret_cast< wxSizer * >(argp2);
55954 {
55955 arg3 = &temp3;
55956 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
55957 }
55958 {
55959 PyThreadState* __tstate = wxPyBeginAllowThreads();
55960 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
55961 wxPyEndAllowThreads(__tstate);
55962 if (PyErr_Occurred()) SWIG_fail;
55963 }
55964 {
55965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55966 }
55967 return resultobj;
55968 fail:
55969 return NULL;
55970 }
55971
55972
55973 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55974 PyObject *resultobj = 0;
55975 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55976 size_t arg2 ;
55977 wxGBSpan *arg3 = 0 ;
55978 bool result;
55979 void *argp1 = 0 ;
55980 int res1 = 0 ;
55981 size_t val2 ;
55982 int ecode2 = 0 ;
55983 wxGBSpan temp3 ;
55984
55985 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55987 if (!SWIG_IsOK(res1)) {
55988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55989 }
55990 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55991 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
55992 if (!SWIG_IsOK(ecode2)) {
55993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
55994 }
55995 arg2 = static_cast< size_t >(val2);
55996 {
55997 arg3 = &temp3;
55998 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
55999 }
56000 {
56001 PyThreadState* __tstate = wxPyBeginAllowThreads();
56002 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56003 wxPyEndAllowThreads(__tstate);
56004 if (PyErr_Occurred()) SWIG_fail;
56005 }
56006 {
56007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56008 }
56009 return resultobj;
56010 fail:
56011 return NULL;
56012 }
56013
56014
56015 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
56016 int argc;
56017 PyObject *argv[4];
56018
56019 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
56020 --argc;
56021 if (argc == 3) {
56022 int _v = 0;
56023 {
56024 void *vptr = 0;
56025 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56026 _v = SWIG_CheckState(res);
56027 }
56028 if (!_v) goto check_1;
56029 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
56030 }
56031 check_1:
56032
56033 if (argc == 3) {
56034 int _v = 0;
56035 {
56036 void *vptr = 0;
56037 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56038 _v = SWIG_CheckState(res);
56039 }
56040 if (!_v) goto check_2;
56041 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
56042 }
56043 check_2:
56044
56045 if (argc == 3) {
56046 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
56047 }
56048
56049 fail:
56050 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
56051 return NULL;
56052 }
56053
56054
56055 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56056 PyObject *resultobj = 0;
56057 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56058 wxWindow *arg2 = (wxWindow *) 0 ;
56059 wxGBSizerItem *result = 0 ;
56060 void *argp1 = 0 ;
56061 int res1 = 0 ;
56062 void *argp2 = 0 ;
56063 int res2 = 0 ;
56064
56065 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56067 if (!SWIG_IsOK(res1)) {
56068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56069 }
56070 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56071 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56072 if (!SWIG_IsOK(res2)) {
56073 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
56074 }
56075 arg2 = reinterpret_cast< wxWindow * >(argp2);
56076 {
56077 PyThreadState* __tstate = wxPyBeginAllowThreads();
56078 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56079 wxPyEndAllowThreads(__tstate);
56080 if (PyErr_Occurred()) SWIG_fail;
56081 }
56082 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56083 return resultobj;
56084 fail:
56085 return NULL;
56086 }
56087
56088
56089 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56090 PyObject *resultobj = 0;
56091 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56092 wxSizer *arg2 = (wxSizer *) 0 ;
56093 wxGBSizerItem *result = 0 ;
56094 void *argp1 = 0 ;
56095 int res1 = 0 ;
56096 void *argp2 = 0 ;
56097 int res2 = 0 ;
56098
56099 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56101 if (!SWIG_IsOK(res1)) {
56102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56103 }
56104 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56105 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56106 if (!SWIG_IsOK(res2)) {
56107 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
56108 }
56109 arg2 = reinterpret_cast< wxSizer * >(argp2);
56110 {
56111 PyThreadState* __tstate = wxPyBeginAllowThreads();
56112 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56113 wxPyEndAllowThreads(__tstate);
56114 if (PyErr_Occurred()) SWIG_fail;
56115 }
56116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56117 return resultobj;
56118 fail:
56119 return NULL;
56120 }
56121
56122
56123 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
56124 int argc;
56125 PyObject *argv[3];
56126
56127 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
56128 --argc;
56129 if (argc == 2) {
56130 int _v = 0;
56131 {
56132 void *vptr = 0;
56133 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56134 _v = SWIG_CheckState(res);
56135 }
56136 if (!_v) goto check_1;
56137 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
56138 }
56139 check_1:
56140
56141 if (argc == 2) {
56142 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
56143 }
56144
56145 fail:
56146 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
56147 return NULL;
56148 }
56149
56150
56151 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56152 PyObject *resultobj = 0;
56153 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56154 wxGBPosition *arg2 = 0 ;
56155 wxGBSizerItem *result = 0 ;
56156 void *argp1 = 0 ;
56157 int res1 = 0 ;
56158 wxGBPosition temp2 ;
56159 PyObject * obj0 = 0 ;
56160 PyObject * obj1 = 0 ;
56161 char * kwnames[] = {
56162 (char *) "self",(char *) "pos", NULL
56163 };
56164
56165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
56166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56167 if (!SWIG_IsOK(res1)) {
56168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56169 }
56170 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56171 {
56172 arg2 = &temp2;
56173 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
56174 }
56175 {
56176 PyThreadState* __tstate = wxPyBeginAllowThreads();
56177 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
56178 wxPyEndAllowThreads(__tstate);
56179 if (PyErr_Occurred()) SWIG_fail;
56180 }
56181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56182 return resultobj;
56183 fail:
56184 return NULL;
56185 }
56186
56187
56188 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56189 PyObject *resultobj = 0;
56190 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56191 wxPoint *arg2 = 0 ;
56192 wxGBSizerItem *result = 0 ;
56193 void *argp1 = 0 ;
56194 int res1 = 0 ;
56195 wxPoint temp2 ;
56196 PyObject * obj0 = 0 ;
56197 PyObject * obj1 = 0 ;
56198 char * kwnames[] = {
56199 (char *) "self",(char *) "pt", NULL
56200 };
56201
56202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
56203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56204 if (!SWIG_IsOK(res1)) {
56205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56206 }
56207 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56208 {
56209 arg2 = &temp2;
56210 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
56211 }
56212 {
56213 PyThreadState* __tstate = wxPyBeginAllowThreads();
56214 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
56215 wxPyEndAllowThreads(__tstate);
56216 if (PyErr_Occurred()) SWIG_fail;
56217 }
56218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56219 return resultobj;
56220 fail:
56221 return NULL;
56222 }
56223
56224
56225 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56226 PyObject *resultobj = 0;
56227 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56228 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
56229 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
56230 bool result;
56231 void *argp1 = 0 ;
56232 int res1 = 0 ;
56233 void *argp2 = 0 ;
56234 int res2 = 0 ;
56235 void *argp3 = 0 ;
56236 int res3 = 0 ;
56237 PyObject * obj0 = 0 ;
56238 PyObject * obj1 = 0 ;
56239 PyObject * obj2 = 0 ;
56240 char * kwnames[] = {
56241 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
56242 };
56243
56244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56246 if (!SWIG_IsOK(res1)) {
56247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56248 }
56249 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56250 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56251 if (!SWIG_IsOK(res2)) {
56252 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
56253 }
56254 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
56255 if (obj2) {
56256 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56257 if (!SWIG_IsOK(res3)) {
56258 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
56259 }
56260 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
56261 }
56262 {
56263 PyThreadState* __tstate = wxPyBeginAllowThreads();
56264 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
56265 wxPyEndAllowThreads(__tstate);
56266 if (PyErr_Occurred()) SWIG_fail;
56267 }
56268 {
56269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56270 }
56271 return resultobj;
56272 fail:
56273 return NULL;
56274 }
56275
56276
56277 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56278 PyObject *resultobj = 0;
56279 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56280 wxGBPosition *arg2 = 0 ;
56281 wxGBSpan *arg3 = 0 ;
56282 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
56283 bool result;
56284 void *argp1 = 0 ;
56285 int res1 = 0 ;
56286 wxGBPosition temp2 ;
56287 wxGBSpan temp3 ;
56288 void *argp4 = 0 ;
56289 int res4 = 0 ;
56290 PyObject * obj0 = 0 ;
56291 PyObject * obj1 = 0 ;
56292 PyObject * obj2 = 0 ;
56293 PyObject * obj3 = 0 ;
56294 char * kwnames[] = {
56295 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
56296 };
56297
56298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56300 if (!SWIG_IsOK(res1)) {
56301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56302 }
56303 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56304 {
56305 arg2 = &temp2;
56306 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
56307 }
56308 {
56309 arg3 = &temp3;
56310 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
56311 }
56312 if (obj3) {
56313 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56314 if (!SWIG_IsOK(res4)) {
56315 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
56316 }
56317 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
56318 }
56319 {
56320 PyThreadState* __tstate = wxPyBeginAllowThreads();
56321 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
56322 wxPyEndAllowThreads(__tstate);
56323 if (PyErr_Occurred()) SWIG_fail;
56324 }
56325 {
56326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56327 }
56328 return resultobj;
56329 fail:
56330 return NULL;
56331 }
56332
56333
56334 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56335 PyObject *obj;
56336 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56337 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
56338 return SWIG_Py_Void();
56339 }
56340
56341 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56342 return SWIG_Python_InitShadowInstance(args);
56343 }
56344
56345 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56346 PyObject *resultobj = 0;
56347 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56348 wxRelationship arg2 ;
56349 wxWindow *arg3 = (wxWindow *) 0 ;
56350 wxEdge arg4 ;
56351 int arg5 = (int) 0 ;
56352 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
56353 void *argp1 = 0 ;
56354 int res1 = 0 ;
56355 int val2 ;
56356 int ecode2 = 0 ;
56357 void *argp3 = 0 ;
56358 int res3 = 0 ;
56359 int val4 ;
56360 int ecode4 = 0 ;
56361 int val5 ;
56362 int ecode5 = 0 ;
56363 int val6 ;
56364 int ecode6 = 0 ;
56365 PyObject * obj0 = 0 ;
56366 PyObject * obj1 = 0 ;
56367 PyObject * obj2 = 0 ;
56368 PyObject * obj3 = 0 ;
56369 PyObject * obj4 = 0 ;
56370 PyObject * obj5 = 0 ;
56371 char * kwnames[] = {
56372 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
56373 };
56374
56375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
56376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56377 if (!SWIG_IsOK(res1)) {
56378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56379 }
56380 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56381 ecode2 = SWIG_AsVal_int(obj1, &val2);
56382 if (!SWIG_IsOK(ecode2)) {
56383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
56384 }
56385 arg2 = static_cast< wxRelationship >(val2);
56386 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56387 if (!SWIG_IsOK(res3)) {
56388 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
56389 }
56390 arg3 = reinterpret_cast< wxWindow * >(argp3);
56391 ecode4 = SWIG_AsVal_int(obj3, &val4);
56392 if (!SWIG_IsOK(ecode4)) {
56393 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
56394 }
56395 arg4 = static_cast< wxEdge >(val4);
56396 if (obj4) {
56397 ecode5 = SWIG_AsVal_int(obj4, &val5);
56398 if (!SWIG_IsOK(ecode5)) {
56399 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
56400 }
56401 arg5 = static_cast< int >(val5);
56402 }
56403 if (obj5) {
56404 ecode6 = SWIG_AsVal_int(obj5, &val6);
56405 if (!SWIG_IsOK(ecode6)) {
56406 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
56407 }
56408 arg6 = static_cast< int >(val6);
56409 }
56410 {
56411 PyThreadState* __tstate = wxPyBeginAllowThreads();
56412 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
56413 wxPyEndAllowThreads(__tstate);
56414 if (PyErr_Occurred()) SWIG_fail;
56415 }
56416 resultobj = SWIG_Py_Void();
56417 return resultobj;
56418 fail:
56419 return NULL;
56420 }
56421
56422
56423 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56424 PyObject *resultobj = 0;
56425 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56426 wxWindow *arg2 = (wxWindow *) 0 ;
56427 int arg3 = (int) 0 ;
56428 void *argp1 = 0 ;
56429 int res1 = 0 ;
56430 void *argp2 = 0 ;
56431 int res2 = 0 ;
56432 int val3 ;
56433 int ecode3 = 0 ;
56434 PyObject * obj0 = 0 ;
56435 PyObject * obj1 = 0 ;
56436 PyObject * obj2 = 0 ;
56437 char * kwnames[] = {
56438 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56439 };
56440
56441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56443 if (!SWIG_IsOK(res1)) {
56444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56445 }
56446 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56447 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56448 if (!SWIG_IsOK(res2)) {
56449 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
56450 }
56451 arg2 = reinterpret_cast< wxWindow * >(argp2);
56452 if (obj2) {
56453 ecode3 = SWIG_AsVal_int(obj2, &val3);
56454 if (!SWIG_IsOK(ecode3)) {
56455 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
56456 }
56457 arg3 = static_cast< int >(val3);
56458 }
56459 {
56460 PyThreadState* __tstate = wxPyBeginAllowThreads();
56461 (arg1)->LeftOf(arg2,arg3);
56462 wxPyEndAllowThreads(__tstate);
56463 if (PyErr_Occurred()) SWIG_fail;
56464 }
56465 resultobj = SWIG_Py_Void();
56466 return resultobj;
56467 fail:
56468 return NULL;
56469 }
56470
56471
56472 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56473 PyObject *resultobj = 0;
56474 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56475 wxWindow *arg2 = (wxWindow *) 0 ;
56476 int arg3 = (int) 0 ;
56477 void *argp1 = 0 ;
56478 int res1 = 0 ;
56479 void *argp2 = 0 ;
56480 int res2 = 0 ;
56481 int val3 ;
56482 int ecode3 = 0 ;
56483 PyObject * obj0 = 0 ;
56484 PyObject * obj1 = 0 ;
56485 PyObject * obj2 = 0 ;
56486 char * kwnames[] = {
56487 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56488 };
56489
56490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56492 if (!SWIG_IsOK(res1)) {
56493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56494 }
56495 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56496 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56497 if (!SWIG_IsOK(res2)) {
56498 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
56499 }
56500 arg2 = reinterpret_cast< wxWindow * >(argp2);
56501 if (obj2) {
56502 ecode3 = SWIG_AsVal_int(obj2, &val3);
56503 if (!SWIG_IsOK(ecode3)) {
56504 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
56505 }
56506 arg3 = static_cast< int >(val3);
56507 }
56508 {
56509 PyThreadState* __tstate = wxPyBeginAllowThreads();
56510 (arg1)->RightOf(arg2,arg3);
56511 wxPyEndAllowThreads(__tstate);
56512 if (PyErr_Occurred()) SWIG_fail;
56513 }
56514 resultobj = SWIG_Py_Void();
56515 return resultobj;
56516 fail:
56517 return NULL;
56518 }
56519
56520
56521 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56522 PyObject *resultobj = 0;
56523 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56524 wxWindow *arg2 = (wxWindow *) 0 ;
56525 int arg3 = (int) 0 ;
56526 void *argp1 = 0 ;
56527 int res1 = 0 ;
56528 void *argp2 = 0 ;
56529 int res2 = 0 ;
56530 int val3 ;
56531 int ecode3 = 0 ;
56532 PyObject * obj0 = 0 ;
56533 PyObject * obj1 = 0 ;
56534 PyObject * obj2 = 0 ;
56535 char * kwnames[] = {
56536 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56537 };
56538
56539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56541 if (!SWIG_IsOK(res1)) {
56542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56543 }
56544 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56545 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56546 if (!SWIG_IsOK(res2)) {
56547 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
56548 }
56549 arg2 = reinterpret_cast< wxWindow * >(argp2);
56550 if (obj2) {
56551 ecode3 = SWIG_AsVal_int(obj2, &val3);
56552 if (!SWIG_IsOK(ecode3)) {
56553 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
56554 }
56555 arg3 = static_cast< int >(val3);
56556 }
56557 {
56558 PyThreadState* __tstate = wxPyBeginAllowThreads();
56559 (arg1)->Above(arg2,arg3);
56560 wxPyEndAllowThreads(__tstate);
56561 if (PyErr_Occurred()) SWIG_fail;
56562 }
56563 resultobj = SWIG_Py_Void();
56564 return resultobj;
56565 fail:
56566 return NULL;
56567 }
56568
56569
56570 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56571 PyObject *resultobj = 0;
56572 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56573 wxWindow *arg2 = (wxWindow *) 0 ;
56574 int arg3 = (int) 0 ;
56575 void *argp1 = 0 ;
56576 int res1 = 0 ;
56577 void *argp2 = 0 ;
56578 int res2 = 0 ;
56579 int val3 ;
56580 int ecode3 = 0 ;
56581 PyObject * obj0 = 0 ;
56582 PyObject * obj1 = 0 ;
56583 PyObject * obj2 = 0 ;
56584 char * kwnames[] = {
56585 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56586 };
56587
56588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56590 if (!SWIG_IsOK(res1)) {
56591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56592 }
56593 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56594 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56595 if (!SWIG_IsOK(res2)) {
56596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
56597 }
56598 arg2 = reinterpret_cast< wxWindow * >(argp2);
56599 if (obj2) {
56600 ecode3 = SWIG_AsVal_int(obj2, &val3);
56601 if (!SWIG_IsOK(ecode3)) {
56602 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
56603 }
56604 arg3 = static_cast< int >(val3);
56605 }
56606 {
56607 PyThreadState* __tstate = wxPyBeginAllowThreads();
56608 (arg1)->Below(arg2,arg3);
56609 wxPyEndAllowThreads(__tstate);
56610 if (PyErr_Occurred()) SWIG_fail;
56611 }
56612 resultobj = SWIG_Py_Void();
56613 return resultobj;
56614 fail:
56615 return NULL;
56616 }
56617
56618
56619 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56620 PyObject *resultobj = 0;
56621 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56622 wxWindow *arg2 = (wxWindow *) 0 ;
56623 wxEdge arg3 ;
56624 int arg4 = (int) 0 ;
56625 void *argp1 = 0 ;
56626 int res1 = 0 ;
56627 void *argp2 = 0 ;
56628 int res2 = 0 ;
56629 int val3 ;
56630 int ecode3 = 0 ;
56631 int val4 ;
56632 int ecode4 = 0 ;
56633 PyObject * obj0 = 0 ;
56634 PyObject * obj1 = 0 ;
56635 PyObject * obj2 = 0 ;
56636 PyObject * obj3 = 0 ;
56637 char * kwnames[] = {
56638 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
56639 };
56640
56641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56643 if (!SWIG_IsOK(res1)) {
56644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56645 }
56646 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56647 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56648 if (!SWIG_IsOK(res2)) {
56649 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
56650 }
56651 arg2 = reinterpret_cast< wxWindow * >(argp2);
56652 ecode3 = SWIG_AsVal_int(obj2, &val3);
56653 if (!SWIG_IsOK(ecode3)) {
56654 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
56655 }
56656 arg3 = static_cast< wxEdge >(val3);
56657 if (obj3) {
56658 ecode4 = SWIG_AsVal_int(obj3, &val4);
56659 if (!SWIG_IsOK(ecode4)) {
56660 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
56661 }
56662 arg4 = static_cast< int >(val4);
56663 }
56664 {
56665 PyThreadState* __tstate = wxPyBeginAllowThreads();
56666 (arg1)->SameAs(arg2,arg3,arg4);
56667 wxPyEndAllowThreads(__tstate);
56668 if (PyErr_Occurred()) SWIG_fail;
56669 }
56670 resultobj = SWIG_Py_Void();
56671 return resultobj;
56672 fail:
56673 return NULL;
56674 }
56675
56676
56677 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56678 PyObject *resultobj = 0;
56679 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56680 wxWindow *arg2 = (wxWindow *) 0 ;
56681 wxEdge arg3 ;
56682 int arg4 ;
56683 void *argp1 = 0 ;
56684 int res1 = 0 ;
56685 void *argp2 = 0 ;
56686 int res2 = 0 ;
56687 int val3 ;
56688 int ecode3 = 0 ;
56689 int val4 ;
56690 int ecode4 = 0 ;
56691 PyObject * obj0 = 0 ;
56692 PyObject * obj1 = 0 ;
56693 PyObject * obj2 = 0 ;
56694 PyObject * obj3 = 0 ;
56695 char * kwnames[] = {
56696 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
56697 };
56698
56699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56701 if (!SWIG_IsOK(res1)) {
56702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56703 }
56704 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56705 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56706 if (!SWIG_IsOK(res2)) {
56707 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
56708 }
56709 arg2 = reinterpret_cast< wxWindow * >(argp2);
56710 ecode3 = SWIG_AsVal_int(obj2, &val3);
56711 if (!SWIG_IsOK(ecode3)) {
56712 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
56713 }
56714 arg3 = static_cast< wxEdge >(val3);
56715 ecode4 = SWIG_AsVal_int(obj3, &val4);
56716 if (!SWIG_IsOK(ecode4)) {
56717 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
56718 }
56719 arg4 = static_cast< int >(val4);
56720 {
56721 PyThreadState* __tstate = wxPyBeginAllowThreads();
56722 (arg1)->PercentOf(arg2,arg3,arg4);
56723 wxPyEndAllowThreads(__tstate);
56724 if (PyErr_Occurred()) SWIG_fail;
56725 }
56726 resultobj = SWIG_Py_Void();
56727 return resultobj;
56728 fail:
56729 return NULL;
56730 }
56731
56732
56733 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56734 PyObject *resultobj = 0;
56735 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56736 int arg2 ;
56737 void *argp1 = 0 ;
56738 int res1 = 0 ;
56739 int val2 ;
56740 int ecode2 = 0 ;
56741 PyObject * obj0 = 0 ;
56742 PyObject * obj1 = 0 ;
56743 char * kwnames[] = {
56744 (char *) "self",(char *) "val", NULL
56745 };
56746
56747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
56748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56749 if (!SWIG_IsOK(res1)) {
56750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56751 }
56752 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56753 ecode2 = SWIG_AsVal_int(obj1, &val2);
56754 if (!SWIG_IsOK(ecode2)) {
56755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
56756 }
56757 arg2 = static_cast< int >(val2);
56758 {
56759 PyThreadState* __tstate = wxPyBeginAllowThreads();
56760 (arg1)->Absolute(arg2);
56761 wxPyEndAllowThreads(__tstate);
56762 if (PyErr_Occurred()) SWIG_fail;
56763 }
56764 resultobj = SWIG_Py_Void();
56765 return resultobj;
56766 fail:
56767 return NULL;
56768 }
56769
56770
56771 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56772 PyObject *resultobj = 0;
56773 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56774 void *argp1 = 0 ;
56775 int res1 = 0 ;
56776 PyObject *swig_obj[1] ;
56777
56778 if (!args) SWIG_fail;
56779 swig_obj[0] = args;
56780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56781 if (!SWIG_IsOK(res1)) {
56782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56783 }
56784 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56785 {
56786 PyThreadState* __tstate = wxPyBeginAllowThreads();
56787 (arg1)->Unconstrained();
56788 wxPyEndAllowThreads(__tstate);
56789 if (PyErr_Occurred()) SWIG_fail;
56790 }
56791 resultobj = SWIG_Py_Void();
56792 return resultobj;
56793 fail:
56794 return NULL;
56795 }
56796
56797
56798 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56799 PyObject *resultobj = 0;
56800 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56801 void *argp1 = 0 ;
56802 int res1 = 0 ;
56803 PyObject *swig_obj[1] ;
56804
56805 if (!args) SWIG_fail;
56806 swig_obj[0] = args;
56807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56808 if (!SWIG_IsOK(res1)) {
56809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56810 }
56811 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56812 {
56813 PyThreadState* __tstate = wxPyBeginAllowThreads();
56814 (arg1)->AsIs();
56815 wxPyEndAllowThreads(__tstate);
56816 if (PyErr_Occurred()) SWIG_fail;
56817 }
56818 resultobj = SWIG_Py_Void();
56819 return resultobj;
56820 fail:
56821 return NULL;
56822 }
56823
56824
56825 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56826 PyObject *resultobj = 0;
56827 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56828 wxWindow *result = 0 ;
56829 void *argp1 = 0 ;
56830 int res1 = 0 ;
56831 PyObject *swig_obj[1] ;
56832
56833 if (!args) SWIG_fail;
56834 swig_obj[0] = args;
56835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56836 if (!SWIG_IsOK(res1)) {
56837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56838 }
56839 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56840 {
56841 PyThreadState* __tstate = wxPyBeginAllowThreads();
56842 result = (wxWindow *)(arg1)->GetOtherWindow();
56843 wxPyEndAllowThreads(__tstate);
56844 if (PyErr_Occurred()) SWIG_fail;
56845 }
56846 {
56847 resultobj = wxPyMake_wxObject(result, 0);
56848 }
56849 return resultobj;
56850 fail:
56851 return NULL;
56852 }
56853
56854
56855 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56856 PyObject *resultobj = 0;
56857 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56858 wxEdge result;
56859 void *argp1 = 0 ;
56860 int res1 = 0 ;
56861 PyObject *swig_obj[1] ;
56862
56863 if (!args) SWIG_fail;
56864 swig_obj[0] = args;
56865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56866 if (!SWIG_IsOK(res1)) {
56867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56868 }
56869 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56870 {
56871 PyThreadState* __tstate = wxPyBeginAllowThreads();
56872 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
56873 wxPyEndAllowThreads(__tstate);
56874 if (PyErr_Occurred()) SWIG_fail;
56875 }
56876 resultobj = SWIG_From_int(static_cast< int >(result));
56877 return resultobj;
56878 fail:
56879 return NULL;
56880 }
56881
56882
56883 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56884 PyObject *resultobj = 0;
56885 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56886 wxEdge arg2 ;
56887 void *argp1 = 0 ;
56888 int res1 = 0 ;
56889 int val2 ;
56890 int ecode2 = 0 ;
56891 PyObject * obj0 = 0 ;
56892 PyObject * obj1 = 0 ;
56893 char * kwnames[] = {
56894 (char *) "self",(char *) "which", NULL
56895 };
56896
56897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
56898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56899 if (!SWIG_IsOK(res1)) {
56900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56901 }
56902 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56903 ecode2 = SWIG_AsVal_int(obj1, &val2);
56904 if (!SWIG_IsOK(ecode2)) {
56905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
56906 }
56907 arg2 = static_cast< wxEdge >(val2);
56908 {
56909 PyThreadState* __tstate = wxPyBeginAllowThreads();
56910 (arg1)->SetEdge(arg2);
56911 wxPyEndAllowThreads(__tstate);
56912 if (PyErr_Occurred()) SWIG_fail;
56913 }
56914 resultobj = SWIG_Py_Void();
56915 return resultobj;
56916 fail:
56917 return NULL;
56918 }
56919
56920
56921 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56922 PyObject *resultobj = 0;
56923 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56924 int arg2 ;
56925 void *argp1 = 0 ;
56926 int res1 = 0 ;
56927 int val2 ;
56928 int ecode2 = 0 ;
56929 PyObject * obj0 = 0 ;
56930 PyObject * obj1 = 0 ;
56931 char * kwnames[] = {
56932 (char *) "self",(char *) "v", NULL
56933 };
56934
56935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
56936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56937 if (!SWIG_IsOK(res1)) {
56938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56939 }
56940 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56941 ecode2 = SWIG_AsVal_int(obj1, &val2);
56942 if (!SWIG_IsOK(ecode2)) {
56943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
56944 }
56945 arg2 = static_cast< int >(val2);
56946 {
56947 PyThreadState* __tstate = wxPyBeginAllowThreads();
56948 (arg1)->SetValue(arg2);
56949 wxPyEndAllowThreads(__tstate);
56950 if (PyErr_Occurred()) SWIG_fail;
56951 }
56952 resultobj = SWIG_Py_Void();
56953 return resultobj;
56954 fail:
56955 return NULL;
56956 }
56957
56958
56959 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56960 PyObject *resultobj = 0;
56961 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56962 int result;
56963 void *argp1 = 0 ;
56964 int res1 = 0 ;
56965 PyObject *swig_obj[1] ;
56966
56967 if (!args) SWIG_fail;
56968 swig_obj[0] = args;
56969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56970 if (!SWIG_IsOK(res1)) {
56971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56972 }
56973 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56974 {
56975 PyThreadState* __tstate = wxPyBeginAllowThreads();
56976 result = (int)(arg1)->GetMargin();
56977 wxPyEndAllowThreads(__tstate);
56978 if (PyErr_Occurred()) SWIG_fail;
56979 }
56980 resultobj = SWIG_From_int(static_cast< int >(result));
56981 return resultobj;
56982 fail:
56983 return NULL;
56984 }
56985
56986
56987 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56988 PyObject *resultobj = 0;
56989 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56990 int arg2 ;
56991 void *argp1 = 0 ;
56992 int res1 = 0 ;
56993 int val2 ;
56994 int ecode2 = 0 ;
56995 PyObject * obj0 = 0 ;
56996 PyObject * obj1 = 0 ;
56997 char * kwnames[] = {
56998 (char *) "self",(char *) "m", NULL
56999 };
57000
57001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
57002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57003 if (!SWIG_IsOK(res1)) {
57004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57005 }
57006 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57007 ecode2 = SWIG_AsVal_int(obj1, &val2);
57008 if (!SWIG_IsOK(ecode2)) {
57009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
57010 }
57011 arg2 = static_cast< int >(val2);
57012 {
57013 PyThreadState* __tstate = wxPyBeginAllowThreads();
57014 (arg1)->SetMargin(arg2);
57015 wxPyEndAllowThreads(__tstate);
57016 if (PyErr_Occurred()) SWIG_fail;
57017 }
57018 resultobj = SWIG_Py_Void();
57019 return resultobj;
57020 fail:
57021 return NULL;
57022 }
57023
57024
57025 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57026 PyObject *resultobj = 0;
57027 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57028 int result;
57029 void *argp1 = 0 ;
57030 int res1 = 0 ;
57031 PyObject *swig_obj[1] ;
57032
57033 if (!args) SWIG_fail;
57034 swig_obj[0] = args;
57035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57036 if (!SWIG_IsOK(res1)) {
57037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57038 }
57039 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57040 {
57041 PyThreadState* __tstate = wxPyBeginAllowThreads();
57042 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
57043 wxPyEndAllowThreads(__tstate);
57044 if (PyErr_Occurred()) SWIG_fail;
57045 }
57046 resultobj = SWIG_From_int(static_cast< int >(result));
57047 return resultobj;
57048 fail:
57049 return NULL;
57050 }
57051
57052
57053 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57054 PyObject *resultobj = 0;
57055 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57056 int result;
57057 void *argp1 = 0 ;
57058 int res1 = 0 ;
57059 PyObject *swig_obj[1] ;
57060
57061 if (!args) SWIG_fail;
57062 swig_obj[0] = args;
57063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57064 if (!SWIG_IsOK(res1)) {
57065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57066 }
57067 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57068 {
57069 PyThreadState* __tstate = wxPyBeginAllowThreads();
57070 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
57071 wxPyEndAllowThreads(__tstate);
57072 if (PyErr_Occurred()) SWIG_fail;
57073 }
57074 resultobj = SWIG_From_int(static_cast< int >(result));
57075 return resultobj;
57076 fail:
57077 return NULL;
57078 }
57079
57080
57081 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57082 PyObject *resultobj = 0;
57083 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57084 int result;
57085 void *argp1 = 0 ;
57086 int res1 = 0 ;
57087 PyObject *swig_obj[1] ;
57088
57089 if (!args) SWIG_fail;
57090 swig_obj[0] = args;
57091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57092 if (!SWIG_IsOK(res1)) {
57093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57094 }
57095 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57096 {
57097 PyThreadState* __tstate = wxPyBeginAllowThreads();
57098 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
57099 wxPyEndAllowThreads(__tstate);
57100 if (PyErr_Occurred()) SWIG_fail;
57101 }
57102 resultobj = SWIG_From_int(static_cast< int >(result));
57103 return resultobj;
57104 fail:
57105 return NULL;
57106 }
57107
57108
57109 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57110 PyObject *resultobj = 0;
57111 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57112 bool result;
57113 void *argp1 = 0 ;
57114 int res1 = 0 ;
57115 PyObject *swig_obj[1] ;
57116
57117 if (!args) SWIG_fail;
57118 swig_obj[0] = args;
57119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57120 if (!SWIG_IsOK(res1)) {
57121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57122 }
57123 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57124 {
57125 PyThreadState* __tstate = wxPyBeginAllowThreads();
57126 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
57127 wxPyEndAllowThreads(__tstate);
57128 if (PyErr_Occurred()) SWIG_fail;
57129 }
57130 {
57131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57132 }
57133 return resultobj;
57134 fail:
57135 return NULL;
57136 }
57137
57138
57139 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57140 PyObject *resultobj = 0;
57141 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57142 bool arg2 ;
57143 void *argp1 = 0 ;
57144 int res1 = 0 ;
57145 bool val2 ;
57146 int ecode2 = 0 ;
57147 PyObject * obj0 = 0 ;
57148 PyObject * obj1 = 0 ;
57149 char * kwnames[] = {
57150 (char *) "self",(char *) "d", NULL
57151 };
57152
57153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
57154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57155 if (!SWIG_IsOK(res1)) {
57156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57157 }
57158 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57159 ecode2 = SWIG_AsVal_bool(obj1, &val2);
57160 if (!SWIG_IsOK(ecode2)) {
57161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
57162 }
57163 arg2 = static_cast< bool >(val2);
57164 {
57165 PyThreadState* __tstate = wxPyBeginAllowThreads();
57166 (arg1)->SetDone(arg2);
57167 wxPyEndAllowThreads(__tstate);
57168 if (PyErr_Occurred()) SWIG_fail;
57169 }
57170 resultobj = SWIG_Py_Void();
57171 return resultobj;
57172 fail:
57173 return NULL;
57174 }
57175
57176
57177 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57178 PyObject *resultobj = 0;
57179 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57180 wxRelationship result;
57181 void *argp1 = 0 ;
57182 int res1 = 0 ;
57183 PyObject *swig_obj[1] ;
57184
57185 if (!args) SWIG_fail;
57186 swig_obj[0] = args;
57187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57188 if (!SWIG_IsOK(res1)) {
57189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57190 }
57191 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57192 {
57193 PyThreadState* __tstate = wxPyBeginAllowThreads();
57194 result = (wxRelationship)(arg1)->GetRelationship();
57195 wxPyEndAllowThreads(__tstate);
57196 if (PyErr_Occurred()) SWIG_fail;
57197 }
57198 resultobj = SWIG_From_int(static_cast< int >(result));
57199 return resultobj;
57200 fail:
57201 return NULL;
57202 }
57203
57204
57205 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57206 PyObject *resultobj = 0;
57207 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57208 wxRelationship arg2 ;
57209 void *argp1 = 0 ;
57210 int res1 = 0 ;
57211 int val2 ;
57212 int ecode2 = 0 ;
57213 PyObject * obj0 = 0 ;
57214 PyObject * obj1 = 0 ;
57215 char * kwnames[] = {
57216 (char *) "self",(char *) "r", NULL
57217 };
57218
57219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
57220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57221 if (!SWIG_IsOK(res1)) {
57222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57223 }
57224 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57225 ecode2 = SWIG_AsVal_int(obj1, &val2);
57226 if (!SWIG_IsOK(ecode2)) {
57227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
57228 }
57229 arg2 = static_cast< wxRelationship >(val2);
57230 {
57231 PyThreadState* __tstate = wxPyBeginAllowThreads();
57232 (arg1)->SetRelationship(arg2);
57233 wxPyEndAllowThreads(__tstate);
57234 if (PyErr_Occurred()) SWIG_fail;
57235 }
57236 resultobj = SWIG_Py_Void();
57237 return resultobj;
57238 fail:
57239 return NULL;
57240 }
57241
57242
57243 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57244 PyObject *resultobj = 0;
57245 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57246 wxWindow *arg2 = (wxWindow *) 0 ;
57247 bool result;
57248 void *argp1 = 0 ;
57249 int res1 = 0 ;
57250 void *argp2 = 0 ;
57251 int res2 = 0 ;
57252 PyObject * obj0 = 0 ;
57253 PyObject * obj1 = 0 ;
57254 char * kwnames[] = {
57255 (char *) "self",(char *) "otherW", NULL
57256 };
57257
57258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
57259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57260 if (!SWIG_IsOK(res1)) {
57261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57262 }
57263 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57264 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57265 if (!SWIG_IsOK(res2)) {
57266 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
57267 }
57268 arg2 = reinterpret_cast< wxWindow * >(argp2);
57269 {
57270 PyThreadState* __tstate = wxPyBeginAllowThreads();
57271 result = (bool)(arg1)->ResetIfWin(arg2);
57272 wxPyEndAllowThreads(__tstate);
57273 if (PyErr_Occurred()) SWIG_fail;
57274 }
57275 {
57276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57277 }
57278 return resultobj;
57279 fail:
57280 return NULL;
57281 }
57282
57283
57284 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57285 PyObject *resultobj = 0;
57286 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57287 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
57288 wxWindow *arg3 = (wxWindow *) 0 ;
57289 bool result;
57290 void *argp1 = 0 ;
57291 int res1 = 0 ;
57292 void *argp2 = 0 ;
57293 int res2 = 0 ;
57294 void *argp3 = 0 ;
57295 int res3 = 0 ;
57296 PyObject * obj0 = 0 ;
57297 PyObject * obj1 = 0 ;
57298 PyObject * obj2 = 0 ;
57299 char * kwnames[] = {
57300 (char *) "self",(char *) "constraints",(char *) "win", NULL
57301 };
57302
57303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57305 if (!SWIG_IsOK(res1)) {
57306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57307 }
57308 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57309 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57310 if (!SWIG_IsOK(res2)) {
57311 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
57312 }
57313 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
57314 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57315 if (!SWIG_IsOK(res3)) {
57316 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
57317 }
57318 arg3 = reinterpret_cast< wxWindow * >(argp3);
57319 {
57320 PyThreadState* __tstate = wxPyBeginAllowThreads();
57321 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
57322 wxPyEndAllowThreads(__tstate);
57323 if (PyErr_Occurred()) SWIG_fail;
57324 }
57325 {
57326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57327 }
57328 return resultobj;
57329 fail:
57330 return NULL;
57331 }
57332
57333
57334 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57335 PyObject *resultobj = 0;
57336 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57337 wxEdge arg2 ;
57338 wxWindow *arg3 = (wxWindow *) 0 ;
57339 wxWindow *arg4 = (wxWindow *) 0 ;
57340 int result;
57341 void *argp1 = 0 ;
57342 int res1 = 0 ;
57343 int val2 ;
57344 int ecode2 = 0 ;
57345 void *argp3 = 0 ;
57346 int res3 = 0 ;
57347 void *argp4 = 0 ;
57348 int res4 = 0 ;
57349 PyObject * obj0 = 0 ;
57350 PyObject * obj1 = 0 ;
57351 PyObject * obj2 = 0 ;
57352 PyObject * obj3 = 0 ;
57353 char * kwnames[] = {
57354 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
57355 };
57356
57357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
57358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57359 if (!SWIG_IsOK(res1)) {
57360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57361 }
57362 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57363 ecode2 = SWIG_AsVal_int(obj1, &val2);
57364 if (!SWIG_IsOK(ecode2)) {
57365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
57366 }
57367 arg2 = static_cast< wxEdge >(val2);
57368 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57369 if (!SWIG_IsOK(res3)) {
57370 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
57371 }
57372 arg3 = reinterpret_cast< wxWindow * >(argp3);
57373 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
57374 if (!SWIG_IsOK(res4)) {
57375 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
57376 }
57377 arg4 = reinterpret_cast< wxWindow * >(argp4);
57378 {
57379 PyThreadState* __tstate = wxPyBeginAllowThreads();
57380 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
57381 wxPyEndAllowThreads(__tstate);
57382 if (PyErr_Occurred()) SWIG_fail;
57383 }
57384 resultobj = SWIG_From_int(static_cast< int >(result));
57385 return resultobj;
57386 fail:
57387 return NULL;
57388 }
57389
57390
57391 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57392 PyObject *obj;
57393 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
57394 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
57395 return SWIG_Py_Void();
57396 }
57397
57398 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57399 PyObject *resultobj = 0;
57400 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57401 wxIndividualLayoutConstraint *result = 0 ;
57402 void *argp1 = 0 ;
57403 int res1 = 0 ;
57404 PyObject *swig_obj[1] ;
57405
57406 if (!args) SWIG_fail;
57407 swig_obj[0] = args;
57408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57409 if (!SWIG_IsOK(res1)) {
57410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57411 }
57412 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57413 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
57414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57415 return resultobj;
57416 fail:
57417 return NULL;
57418 }
57419
57420
57421 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57422 PyObject *resultobj = 0;
57423 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57424 wxIndividualLayoutConstraint *result = 0 ;
57425 void *argp1 = 0 ;
57426 int res1 = 0 ;
57427 PyObject *swig_obj[1] ;
57428
57429 if (!args) SWIG_fail;
57430 swig_obj[0] = args;
57431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57432 if (!SWIG_IsOK(res1)) {
57433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57434 }
57435 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57436 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
57437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57438 return resultobj;
57439 fail:
57440 return NULL;
57441 }
57442
57443
57444 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57445 PyObject *resultobj = 0;
57446 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57447 wxIndividualLayoutConstraint *result = 0 ;
57448 void *argp1 = 0 ;
57449 int res1 = 0 ;
57450 PyObject *swig_obj[1] ;
57451
57452 if (!args) SWIG_fail;
57453 swig_obj[0] = args;
57454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57455 if (!SWIG_IsOK(res1)) {
57456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57457 }
57458 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57459 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
57460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57461 return resultobj;
57462 fail:
57463 return NULL;
57464 }
57465
57466
57467 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57468 PyObject *resultobj = 0;
57469 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57470 wxIndividualLayoutConstraint *result = 0 ;
57471 void *argp1 = 0 ;
57472 int res1 = 0 ;
57473 PyObject *swig_obj[1] ;
57474
57475 if (!args) SWIG_fail;
57476 swig_obj[0] = args;
57477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57478 if (!SWIG_IsOK(res1)) {
57479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57480 }
57481 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57482 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
57483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57484 return resultobj;
57485 fail:
57486 return NULL;
57487 }
57488
57489
57490 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57491 PyObject *resultobj = 0;
57492 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57493 wxIndividualLayoutConstraint *result = 0 ;
57494 void *argp1 = 0 ;
57495 int res1 = 0 ;
57496 PyObject *swig_obj[1] ;
57497
57498 if (!args) SWIG_fail;
57499 swig_obj[0] = args;
57500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57501 if (!SWIG_IsOK(res1)) {
57502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57503 }
57504 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57505 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
57506 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57507 return resultobj;
57508 fail:
57509 return NULL;
57510 }
57511
57512
57513 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57514 PyObject *resultobj = 0;
57515 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57516 wxIndividualLayoutConstraint *result = 0 ;
57517 void *argp1 = 0 ;
57518 int res1 = 0 ;
57519 PyObject *swig_obj[1] ;
57520
57521 if (!args) SWIG_fail;
57522 swig_obj[0] = args;
57523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57524 if (!SWIG_IsOK(res1)) {
57525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57526 }
57527 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57528 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
57529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57530 return resultobj;
57531 fail:
57532 return NULL;
57533 }
57534
57535
57536 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57537 PyObject *resultobj = 0;
57538 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57539 wxIndividualLayoutConstraint *result = 0 ;
57540 void *argp1 = 0 ;
57541 int res1 = 0 ;
57542 PyObject *swig_obj[1] ;
57543
57544 if (!args) SWIG_fail;
57545 swig_obj[0] = args;
57546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57547 if (!SWIG_IsOK(res1)) {
57548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57549 }
57550 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57551 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
57552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57553 return resultobj;
57554 fail:
57555 return NULL;
57556 }
57557
57558
57559 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57560 PyObject *resultobj = 0;
57561 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57562 wxIndividualLayoutConstraint *result = 0 ;
57563 void *argp1 = 0 ;
57564 int res1 = 0 ;
57565 PyObject *swig_obj[1] ;
57566
57567 if (!args) SWIG_fail;
57568 swig_obj[0] = args;
57569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57570 if (!SWIG_IsOK(res1)) {
57571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57572 }
57573 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57574 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
57575 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57576 return resultobj;
57577 fail:
57578 return NULL;
57579 }
57580
57581
57582 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57583 PyObject *resultobj = 0;
57584 wxLayoutConstraints *result = 0 ;
57585
57586 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
57587 {
57588 PyThreadState* __tstate = wxPyBeginAllowThreads();
57589 result = (wxLayoutConstraints *)new wxLayoutConstraints();
57590 wxPyEndAllowThreads(__tstate);
57591 if (PyErr_Occurred()) SWIG_fail;
57592 }
57593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
57594 return resultobj;
57595 fail:
57596 return NULL;
57597 }
57598
57599
57600 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57601 PyObject *resultobj = 0;
57602 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57603 void *argp1 = 0 ;
57604 int res1 = 0 ;
57605 PyObject *swig_obj[1] ;
57606
57607 if (!args) SWIG_fail;
57608 swig_obj[0] = args;
57609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
57610 if (!SWIG_IsOK(res1)) {
57611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57612 }
57613 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57614 {
57615 PyThreadState* __tstate = wxPyBeginAllowThreads();
57616 delete arg1;
57617
57618 wxPyEndAllowThreads(__tstate);
57619 if (PyErr_Occurred()) SWIG_fail;
57620 }
57621 resultobj = SWIG_Py_Void();
57622 return resultobj;
57623 fail:
57624 return NULL;
57625 }
57626
57627
57628 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57629 PyObject *resultobj = 0;
57630 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57631 wxWindow *arg2 = (wxWindow *) 0 ;
57632 int *arg3 = (int *) 0 ;
57633 bool result;
57634 void *argp1 = 0 ;
57635 int res1 = 0 ;
57636 void *argp2 = 0 ;
57637 int res2 = 0 ;
57638 int temp3 ;
57639 int res3 = SWIG_TMPOBJ ;
57640 PyObject * obj0 = 0 ;
57641 PyObject * obj1 = 0 ;
57642 char * kwnames[] = {
57643 (char *) "self",(char *) "win", NULL
57644 };
57645
57646 arg3 = &temp3;
57647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
57648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57649 if (!SWIG_IsOK(res1)) {
57650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57651 }
57652 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57653 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57654 if (!SWIG_IsOK(res2)) {
57655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
57656 }
57657 arg2 = reinterpret_cast< wxWindow * >(argp2);
57658 {
57659 PyThreadState* __tstate = wxPyBeginAllowThreads();
57660 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
57661 wxPyEndAllowThreads(__tstate);
57662 if (PyErr_Occurred()) SWIG_fail;
57663 }
57664 {
57665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57666 }
57667 if (SWIG_IsTmpObj(res3)) {
57668 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
57669 } else {
57670 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
57671 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
57672 }
57673 return resultobj;
57674 fail:
57675 return NULL;
57676 }
57677
57678
57679 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57680 PyObject *resultobj = 0;
57681 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57682 bool result;
57683 void *argp1 = 0 ;
57684 int res1 = 0 ;
57685 PyObject *swig_obj[1] ;
57686
57687 if (!args) SWIG_fail;
57688 swig_obj[0] = args;
57689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57690 if (!SWIG_IsOK(res1)) {
57691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
57692 }
57693 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57694 {
57695 PyThreadState* __tstate = wxPyBeginAllowThreads();
57696 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
57697 wxPyEndAllowThreads(__tstate);
57698 if (PyErr_Occurred()) SWIG_fail;
57699 }
57700 {
57701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57702 }
57703 return resultobj;
57704 fail:
57705 return NULL;
57706 }
57707
57708
57709 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57710 PyObject *obj;
57711 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
57712 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
57713 return SWIG_Py_Void();
57714 }
57715
57716 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57717 return SWIG_Python_InitShadowInstance(args);
57718 }
57719
57720 static PyMethodDef SwigMethods[] = {
57721 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
57722 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
57723 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
57724 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57725 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
57726 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
57727 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
57728 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
57729 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
57730 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
57731 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
57732 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57733 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57734 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57735 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
57736 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
57737 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
57738 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
57739 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
57740 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
57741 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57742 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57743 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
57744 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
57745 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
57746 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
57747 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
57748 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
57749 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
57750 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
57751 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
57752 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
57753 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
57754 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
57755 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57756 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
57757 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57758 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57759 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57760 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
57761 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57762 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
57763 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
57764 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
57765 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
57766 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
57767 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
57768 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
57769 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
57770 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
57771 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57772 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57773 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57774 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
57775 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
57776 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
57777 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57778 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
57779 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
57780 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
57781 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
57782 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
57783 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
57784 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
57785 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
57786 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
57787 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
57788 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
57789 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
57790 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
57791 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57792 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
57793 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
57794 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
57795 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57796 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
57797 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57798 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
57799 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
57800 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
57801 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
57802 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
57803 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
57804 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
57805 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
57806 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
57807 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
57808 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
57809 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
57810 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
57811 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
57812 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
57813 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
57814 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
57815 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
57816 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
57817 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
57818 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
57819 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
57820 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
57821 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57822 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
57823 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57824 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57825 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
57826 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
57827 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
57828 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57829 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
57830 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
57831 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
57832 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
57833 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
57834 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
57835 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
57836 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
57837 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
57838 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57839 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
57840 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
57841 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
57842 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
57843 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
57844 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
57845 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57846 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
57847 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
57848 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
57849 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
57850 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
57851 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
57852 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
57853 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
57854 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
57855 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
57856 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
57857 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
57858 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
57859 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
57860 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
57861 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
57862 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57863 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57864 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
57865 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
57866 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
57867 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
57868 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57869 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
57870 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
57871 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
57872 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
57873 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
57874 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
57875 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
57876 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
57877 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
57878 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
57879 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
57880 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
57881 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
57882 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
57883 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
57884 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
57885 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
57886 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
57887 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
57888 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
57889 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
57890 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
57891 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
57892 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
57893 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
57894 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
57895 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
57896 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
57897 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
57898 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
57899 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
57900 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
57901 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
57902 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
57903 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
57904 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
57905 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
57906 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
57907 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57908 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
57909 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
57910 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
57911 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
57912 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
57913 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
57914 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57915 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
57916 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
57917 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
57918 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57919 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57920 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
57921 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
57922 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
57923 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
57924 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
57925 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
57926 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
57927 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
57928 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57929 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
57930 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
57931 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
57932 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
57933 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
57934 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
57935 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
57936 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
57937 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
57938 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
57939 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
57940 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
57941 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
57942 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
57943 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
57944 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
57945 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
57946 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
57947 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
57948 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
57949 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
57950 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
57951 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
57952 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
57953 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
57954 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
57955 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
57956 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
57957 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
57958 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
57959 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
57960 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
57961 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
57962 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
57963 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
57964 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
57965 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
57966 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
57967 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
57968 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57969 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
57970 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
57971 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
57972 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
57973 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
57974 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
57975 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
57976 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
57977 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
57978 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
57979 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
57980 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
57981 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
57982 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
57983 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
57984 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
57985 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
57986 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
57987 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57988 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57989 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
57990 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
57991 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
57992 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
57993 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
57994 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
57995 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
57996 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
57997 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
57998 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
57999 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
58000 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58001 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58002 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58003 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
58004 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
58005 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
58006 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
58007 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58008 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
58009 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
58010 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
58011 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58012 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58013 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58014 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
58015 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
58016 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
58017 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
58018 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
58019 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
58020 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
58021 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
58022 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58023 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
58024 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
58025 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
58026 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
58027 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
58028 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
58029 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58030 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
58031 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
58032 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
58033 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
58034 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58035 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
58036 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58037 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
58038 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
58039 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
58040 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
58041 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
58042 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
58043 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
58044 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
58045 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
58046 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
58047 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
58048 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
58049 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
58050 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
58051 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
58052 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
58053 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
58054 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
58055 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
58056 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
58057 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
58058 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
58059 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
58060 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
58061 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
58062 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
58063 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
58064 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58065 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
58066 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58067 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58068 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
58069 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
58070 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
58071 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
58072 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
58073 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
58074 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
58075 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
58076 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
58077 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
58078 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58079 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
58080 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
58081 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
58082 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
58083 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58084 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58085 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
58086 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
58087 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
58088 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58089 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
58090 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58091 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
58092 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
58093 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
58094 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
58095 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58096 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
58097 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58098 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58099 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58100 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
58101 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
58102 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
58103 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
58104 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
58105 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
58106 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
58107 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
58108 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
58109 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
58110 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
58111 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
58112 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58113 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
58114 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
58115 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
58116 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58117 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
58118 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
58119 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
58120 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
58121 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
58122 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
58123 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
58124 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
58125 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
58126 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
58127 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
58128 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
58129 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
58130 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58131 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58132 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58133 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58134 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
58135 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
58136 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
58137 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58138 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58139 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58140 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
58141 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
58142 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58143 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58144 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
58145 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
58146 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58147 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
58148 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
58149 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58150 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
58151 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
58152 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
58153 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
58154 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
58155 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
58156 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
58157 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
58158 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
58159 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
58160 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
58161 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
58162 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
58163 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
58164 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
58165 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
58166 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
58167 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
58168 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
58169 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
58170 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
58171 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
58172 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
58173 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
58174 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
58175 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
58176 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
58177 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
58178 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
58179 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
58180 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
58181 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
58182 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
58183 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
58184 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
58185 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
58186 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
58187 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
58188 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
58189 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
58190 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
58191 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58192 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58193 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
58194 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58195 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58196 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58197 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
58198 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
58199 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
58200 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58201 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
58202 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
58203 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
58204 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
58205 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
58206 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
58207 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
58208 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
58209 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
58210 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
58211 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
58212 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
58213 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
58214 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
58215 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
58216 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
58217 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
58218 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
58219 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
58220 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
58221 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
58222 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
58223 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
58224 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
58225 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
58226 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
58227 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
58228 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
58229 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58230 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
58231 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
58232 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
58233 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
58234 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
58235 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
58236 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
58237 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
58238 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
58239 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
58240 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
58241 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
58242 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
58243 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
58244 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58245 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
58246 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
58247 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
58248 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
58249 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
58250 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58251 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
58252 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
58253 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58254 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58255 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
58256 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
58257 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58258 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
58259 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
58260 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58261 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58262 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
58263 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
58264 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58265 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
58266 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
58267 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
58268 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
58269 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
58270 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
58271 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
58272 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
58273 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
58274 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
58275 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
58276 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
58277 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
58278 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
58279 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
58280 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
58281 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
58282 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
58283 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
58284 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
58285 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
58286 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
58287 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
58288 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
58289 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
58290 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
58291 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
58292 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
58293 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
58294 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
58295 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58296 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
58297 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
58298 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
58299 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
58300 { (char *)"MouseEvent_GetWheelAxis", (PyCFunction)_wrap_MouseEvent_GetWheelAxis, METH_O, NULL},
58301 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
58302 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
58303 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
58304 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
58305 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
58306 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
58307 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
58308 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
58309 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
58310 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
58311 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
58312 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
58313 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
58314 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
58315 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
58316 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
58317 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
58318 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
58319 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
58320 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
58321 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
58322 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
58323 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
58324 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
58325 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
58326 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
58327 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
58328 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
58329 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58330 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
58331 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
58332 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
58333 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
58334 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
58335 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
58336 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
58337 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58338 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
58339 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
58340 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
58341 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
58342 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
58343 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
58344 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
58345 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
58346 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
58347 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
58348 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
58349 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
58350 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
58351 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
58352 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
58353 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
58354 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
58355 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
58356 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
58357 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
58358 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
58359 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
58360 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
58361 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
58362 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
58363 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
58364 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
58365 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
58366 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
58367 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
58368 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
58369 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
58370 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
58371 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
58372 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
58373 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
58374 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
58375 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
58376 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58377 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
58378 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
58379 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
58380 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
58381 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
58382 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
58383 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
58384 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
58385 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
58386 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
58387 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58388 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
58389 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
58390 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
58391 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58392 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
58393 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
58394 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58395 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
58396 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
58397 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58398 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
58399 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
58400 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58401 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
58402 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
58403 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
58404 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58405 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
58406 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58407 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
58408 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
58409 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58410 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
58411 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
58412 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
58413 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58414 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
58415 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
58416 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
58417 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58418 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
58419 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
58420 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58421 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
58422 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
58423 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
58424 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
58425 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
58426 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58427 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
58428 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
58429 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
58430 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
58431 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
58432 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
58433 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
58434 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
58435 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58436 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
58437 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
58438 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
58439 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
58440 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58441 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
58442 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
58443 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
58444 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58445 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
58446 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
58447 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
58448 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
58449 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
58450 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
58451 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58452 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
58453 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
58454 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
58455 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
58456 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
58457 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
58458 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
58459 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
58460 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
58461 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
58462 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
58463 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
58464 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
58465 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
58466 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
58467 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
58468 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
58469 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
58470 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
58471 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
58472 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
58473 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
58474 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
58475 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58476 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
58477 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
58478 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
58479 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58480 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
58481 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
58482 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
58483 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
58484 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
58485 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58486 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58487 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
58488 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
58489 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
58490 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58491 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
58492 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
58493 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
58494 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
58495 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
58496 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
58497 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
58498 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
58499 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
58500 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
58501 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
58502 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
58503 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
58504 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
58505 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
58506 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
58507 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58508 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
58509 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
58510 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
58511 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58512 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
58513 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
58514 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
58515 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58516 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
58517 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58518 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
58519 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
58520 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
58521 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
58522 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
58523 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
58524 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
58525 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
58526 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
58527 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
58528 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58529 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
58530 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
58531 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58532 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
58533 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58534 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
58535 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
58536 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
58537 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58538 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
58539 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58540 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
58541 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
58542 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
58543 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58544 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
58545 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
58546 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
58547 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
58548 { (char *)"new_EventBlocker", (PyCFunction) _wrap_new_EventBlocker, METH_VARARGS | METH_KEYWORDS, NULL},
58549 { (char *)"delete_EventBlocker", (PyCFunction)_wrap_delete_EventBlocker, METH_O, NULL},
58550 { (char *)"EventBlocker_Block", (PyCFunction) _wrap_EventBlocker_Block, METH_VARARGS | METH_KEYWORDS, NULL},
58551 { (char *)"EventBlocker_swigregister", EventBlocker_swigregister, METH_VARARGS, NULL},
58552 { (char *)"EventBlocker_swiginit", EventBlocker_swiginit, METH_VARARGS, NULL},
58553 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
58554 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
58555 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58556 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
58557 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
58558 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
58559 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
58560 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
58561 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
58562 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
58563 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
58564 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
58565 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
58566 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
58567 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
58568 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
58569 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
58570 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
58571 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
58572 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
58573 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
58574 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
58575 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
58576 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58577 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
58578 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
58579 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
58580 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
58581 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
58582 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
58583 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
58584 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
58585 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
58586 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
58587 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
58588 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
58589 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
58590 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
58591 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
58592 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
58593 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
58594 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
58595 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
58596 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
58597 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
58598 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
58599 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
58600 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
58601 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
58602 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
58603 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
58604 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
58605 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
58606 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58607 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
58608 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
58609 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
58610 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
58611 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
58612 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
58613 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
58614 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
58615 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
58616 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
58617 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
58618 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
58619 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
58620 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
58621 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
58622 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
58623 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
58624 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
58625 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
58626 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
58627 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
58628 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58629 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58630 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
58631 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
58632 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
58633 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
58634 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
58635 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
58636 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
58637 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
58638 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
58639 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
58640 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
58641 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
58642 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
58643 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
58644 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
58645 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
58646 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
58647 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
58648 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
58649 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
58650 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
58651 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
58652 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
58653 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
58654 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
58655 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58656 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
58657 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
58658 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
58659 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
58660 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
58661 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
58662 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
58663 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
58664 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
58665 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
58666 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
58667 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
58668 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
58669 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
58670 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
58671 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
58672 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
58673 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
58674 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
58675 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
58676 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
58677 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
58678 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
58679 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
58680 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
58681 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
58682 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
58683 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
58684 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
58685 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
58686 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
58687 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
58688 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
58689 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
58690 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
58691 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
58692 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
58693 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
58694 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
58695 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
58696 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
58697 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
58698 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
58699 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
58700 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
58701 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
58702 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
58703 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
58704 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
58705 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
58706 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
58707 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
58708 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
58709 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
58710 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
58711 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
58712 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
58713 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
58714 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
58715 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
58716 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
58717 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
58718 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
58719 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
58720 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
58721 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
58722 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
58723 { (char *)"Window_GetWindowBorderSize", (PyCFunction)_wrap_Window_GetWindowBorderSize, METH_O, NULL},
58724 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
58725 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
58726 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
58727 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
58728 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
58729 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
58730 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
58731 { (char *)"Window_IsThisEnabled", (PyCFunction)_wrap_Window_IsThisEnabled, METH_O, NULL},
58732 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
58733 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
58734 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
58735 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
58736 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
58737 { (char *)"Window_ToggleWindowStyle", (PyCFunction) _wrap_Window_ToggleWindowStyle, METH_VARARGS | METH_KEYWORDS, NULL},
58738 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
58739 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
58740 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
58741 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58742 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
58743 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
58744 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
58745 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
58746 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
58747 { (char *)"Window_CanAcceptFocus", (PyCFunction)_wrap_Window_CanAcceptFocus, METH_O, NULL},
58748 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
58749 { (char *)"Window_CanAcceptFocusFromKeyboard", (PyCFunction)_wrap_Window_CanAcceptFocusFromKeyboard, METH_O, NULL},
58750 { (char *)"Window_NavigateIn", (PyCFunction) _wrap_Window_NavigateIn, METH_VARARGS | METH_KEYWORDS, NULL},
58751 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
58752 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
58753 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
58754 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
58755 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
58756 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
58757 { (char *)"Window_GetTopLevelParent", (PyCFunction)_wrap_Window_GetTopLevelParent, METH_O, NULL},
58758 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
58759 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
58760 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
58761 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
58762 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
58763 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
58764 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
58765 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
58766 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58767 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58768 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58769 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58770 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
58771 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
58772 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
58773 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
58774 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
58775 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
58776 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
58777 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
58778 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
58779 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
58780 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
58781 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
58782 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
58783 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
58784 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
58785 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
58786 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
58787 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
58788 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
58789 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
58790 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
58791 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
58792 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
58793 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
58794 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
58795 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
58796 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
58797 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
58798 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
58799 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
58800 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
58801 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
58802 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
58803 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58804 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
58805 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
58806 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
58807 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58808 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58809 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58810 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58811 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
58812 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
58813 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
58814 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
58815 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
58816 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
58817 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
58818 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
58819 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
58820 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
58821 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
58822 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
58823 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
58824 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
58825 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
58826 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
58827 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
58828 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
58829 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
58830 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
58831 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
58832 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
58833 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
58834 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
58835 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
58836 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
58837 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
58838 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58839 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
58840 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
58841 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
58842 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
58843 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
58844 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
58845 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
58846 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
58847 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
58848 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
58849 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
58850 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58851 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
58852 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
58853 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
58854 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
58855 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
58856 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
58857 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
58858 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
58859 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58860 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
58861 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
58862 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
58863 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
58864 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
58865 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
58866 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
58867 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
58868 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
58869 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
58870 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
58871 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
58872 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
58873 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
58874 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
58875 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
58876 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
58877 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
58878 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
58879 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
58880 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
58881 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
58882 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
58883 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
58884 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
58885 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
58886 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
58887 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
58888 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
58889 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
58890 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
58891 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
58892 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
58893 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
58894 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58895 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
58896 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
58897 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
58898 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
58899 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
58900 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58901 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
58902 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
58903 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
58904 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
58905 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
58906 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
58907 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
58908 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58909 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58910 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
58911 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
58912 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
58913 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
58914 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
58915 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
58916 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
58917 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
58918 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58919 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
58920 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
58921 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
58922 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
58923 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58924 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
58925 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
58926 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
58927 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
58928 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
58929 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
58930 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
58931 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
58932 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
58933 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
58934 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
58935 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58936 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
58937 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58938 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
58939 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
58940 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
58941 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
58942 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
58943 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
58944 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
58945 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
58946 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58947 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
58948 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58949 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
58950 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
58951 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
58952 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
58953 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
58954 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
58955 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
58956 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
58957 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
58958 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
58959 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
58960 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
58961 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
58962 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
58963 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
58964 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58965 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
58966 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
58967 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
58968 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
58969 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
58970 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
58971 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
58972 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
58973 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58974 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
58975 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
58976 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
58977 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58978 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
58979 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
58980 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
58981 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
58982 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
58983 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
58984 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
58985 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
58986 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
58987 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58988 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
58989 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
58990 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
58991 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
58992 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
58993 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
58994 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58995 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
58996 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
58997 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
58998 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
58999 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
59000 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
59001 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
59002 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
59003 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
59004 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
59005 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
59006 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
59007 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59008 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
59009 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59010 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
59011 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59012 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
59013 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
59014 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
59015 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
59016 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
59017 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
59018 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
59019 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
59020 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
59021 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
59022 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
59023 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
59024 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59025 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
59026 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
59027 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
59028 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
59029 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
59030 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
59031 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
59032 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
59033 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
59034 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
59035 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
59036 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
59037 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
59038 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
59039 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59040 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
59041 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
59042 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
59043 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
59044 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
59045 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
59046 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59047 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
59048 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59049 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
59050 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
59051 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
59052 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
59053 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
59054 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
59055 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
59056 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
59057 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
59058 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
59059 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
59060 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
59061 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
59062 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
59063 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
59064 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
59065 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
59066 { (char *)"new_SizerFlags", (PyCFunction) _wrap_new_SizerFlags, METH_VARARGS | METH_KEYWORDS, NULL},
59067 { (char *)"delete_SizerFlags", (PyCFunction)_wrap_delete_SizerFlags, METH_O, NULL},
59068 { (char *)"SizerFlags_Proportion", (PyCFunction) _wrap_SizerFlags_Proportion, METH_VARARGS | METH_KEYWORDS, NULL},
59069 { (char *)"SizerFlags_Align", (PyCFunction) _wrap_SizerFlags_Align, METH_VARARGS | METH_KEYWORDS, NULL},
59070 { (char *)"SizerFlags_Expand", (PyCFunction)_wrap_SizerFlags_Expand, METH_O, NULL},
59071 { (char *)"SizerFlags_Centre", (PyCFunction)_wrap_SizerFlags_Centre, METH_O, NULL},
59072 { (char *)"SizerFlags_Center", (PyCFunction)_wrap_SizerFlags_Center, METH_O, NULL},
59073 { (char *)"SizerFlags_Left", (PyCFunction)_wrap_SizerFlags_Left, METH_O, NULL},
59074 { (char *)"SizerFlags_Right", (PyCFunction)_wrap_SizerFlags_Right, METH_O, NULL},
59075 { (char *)"SizerFlags_Top", (PyCFunction)_wrap_SizerFlags_Top, METH_O, NULL},
59076 { (char *)"SizerFlags_Bottom", (PyCFunction)_wrap_SizerFlags_Bottom, METH_O, NULL},
59077 { (char *)"SizerFlags_Shaped", (PyCFunction)_wrap_SizerFlags_Shaped, METH_O, NULL},
59078 { (char *)"SizerFlags_FixedMinSize", (PyCFunction)_wrap_SizerFlags_FixedMinSize, METH_O, NULL},
59079 { (char *)"SizerFlags_Border", (PyCFunction) _wrap_SizerFlags_Border, METH_VARARGS | METH_KEYWORDS, NULL},
59080 { (char *)"SizerFlags_DoubleBorder", (PyCFunction) _wrap_SizerFlags_DoubleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59081 { (char *)"SizerFlags_TripleBorder", (PyCFunction) _wrap_SizerFlags_TripleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59082 { (char *)"SizerFlags_HorzBorder", (PyCFunction)_wrap_SizerFlags_HorzBorder, METH_O, NULL},
59083 { (char *)"SizerFlags_DoubleHorzBorder", (PyCFunction)_wrap_SizerFlags_DoubleHorzBorder, METH_O, NULL},
59084 { (char *)"SizerFlags_GetDefaultBorder", (PyCFunction)_wrap_SizerFlags_GetDefaultBorder, METH_NOARGS, NULL},
59085 { (char *)"SizerFlags_GetProportion", (PyCFunction)_wrap_SizerFlags_GetProportion, METH_O, NULL},
59086 { (char *)"SizerFlags_GetFlags", (PyCFunction)_wrap_SizerFlags_GetFlags, METH_O, NULL},
59087 { (char *)"SizerFlags_GetBorderInPixels", (PyCFunction)_wrap_SizerFlags_GetBorderInPixels, METH_O, NULL},
59088 { (char *)"SizerFlags_swigregister", SizerFlags_swigregister, METH_VARARGS, NULL},
59089 { (char *)"SizerFlags_swiginit", SizerFlags_swiginit, METH_VARARGS, NULL},
59090 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
59091 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
59092 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59093 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59094 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59095 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
59096 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
59097 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
59098 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
59099 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59100 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
59101 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
59102 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
59103 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
59104 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
59105 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
59106 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
59107 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
59108 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
59109 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
59110 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
59111 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
59112 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
59113 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59114 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
59115 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59116 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
59117 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
59118 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59119 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
59120 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59121 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
59122 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59123 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59124 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
59125 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
59126 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
59127 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
59128 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
59129 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
59130 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
59131 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59132 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59133 { (char *)"Sizer_AddF", (PyCFunction) _wrap_Sizer_AddF, METH_VARARGS | METH_KEYWORDS, NULL},
59134 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59135 { (char *)"Sizer_InsertF", (PyCFunction) _wrap_Sizer_InsertF, METH_VARARGS | METH_KEYWORDS, NULL},
59136 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
59137 { (char *)"Sizer_PrependF", (PyCFunction) _wrap_Sizer_PrependF, METH_VARARGS | METH_KEYWORDS, NULL},
59138 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59139 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
59140 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
59141 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59142 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
59143 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59144 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
59145 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59146 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
59147 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59148 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
59149 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
59150 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59151 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59152 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
59153 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
59154 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
59155 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
59156 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
59157 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
59158 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
59159 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
59160 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59161 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59162 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
59163 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
59164 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
59165 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59166 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
59167 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
59168 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
59169 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
59170 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59171 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
59172 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
59173 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59174 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
59175 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
59176 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
59177 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
59178 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59179 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
59180 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
59181 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
59182 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59183 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
59184 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
59185 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
59186 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
59187 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
59188 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
59189 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
59190 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
59191 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
59192 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
59193 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59194 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59195 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59196 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59197 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59198 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59199 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
59200 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
59201 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
59202 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
59203 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
59204 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
59205 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
59206 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
59207 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
59208 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
59209 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59210 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59211 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
59212 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
59213 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
59214 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
59215 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
59216 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
59217 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
59218 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
59219 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59220 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
59221 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
59222 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
59223 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
59224 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
59225 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59226 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59227 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59228 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
59229 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
59230 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
59231 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59232 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
59233 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
59234 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
59235 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
59236 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
59237 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59238 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59239 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59240 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
59241 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
59242 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
59243 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
59244 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
59245 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59246 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59247 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59248 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
59249 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
59250 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
59251 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59252 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
59253 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
59254 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
59255 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
59256 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59257 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
59258 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
59259 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59260 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59261 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59262 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
59263 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
59264 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
59265 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
59266 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
59267 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
59268 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
59269 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
59270 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59271 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59272 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
59273 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
59274 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
59275 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
59276 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59277 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
59278 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
59279 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
59280 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
59281 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
59282 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
59283 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
59284 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
59285 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
59286 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
59287 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
59288 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
59289 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
59290 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
59291 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
59292 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
59293 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
59294 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
59295 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
59296 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
59297 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
59298 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
59299 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
59300 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
59301 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
59302 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
59303 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
59304 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
59305 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
59306 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
59307 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
59308 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
59309 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
59310 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
59311 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
59312 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
59313 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
59314 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
59315 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
59316 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
59317 { NULL, NULL, 0, NULL }
59318 };
59319
59320
59321 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
59322
59323 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
59324 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
59325 }
59326 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
59327 return (void *)((wxEvent *) ((wxMenuEvent *) x));
59328 }
59329 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
59330 return (void *)((wxEvent *) ((wxCloseEvent *) x));
59331 }
59332 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
59333 return (void *)((wxEvent *) ((wxMouseEvent *) x));
59334 }
59335 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
59336 return (void *)((wxEvent *) ((wxEraseEvent *) x));
59337 }
59338 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
59339 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
59340 }
59341 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
59342 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
59343 }
59344 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
59345 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
59346 }
59347 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
59348 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
59349 }
59350 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
59351 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
59352 }
59353 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
59354 return (void *)((wxEvent *) ((wxPyEvent *) x));
59355 }
59356 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
59357 return (void *)((wxEvent *) ((wxIdleEvent *) x));
59358 }
59359 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
59360 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
59361 }
59362 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
59363 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
59364 }
59365 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
59366 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
59367 }
59368 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
59369 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
59370 }
59371 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
59372 return (void *)((wxEvent *) ((wxActivateEvent *) x));
59373 }
59374 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
59375 return (void *)((wxEvent *) ((wxSizeEvent *) x));
59376 }
59377 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
59378 return (void *)((wxEvent *) ((wxMoveEvent *) x));
59379 }
59380 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
59381 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
59382 }
59383 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
59384 return (void *)((wxEvent *) ((wxPaintEvent *) x));
59385 }
59386 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
59387 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
59388 }
59389 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
59390 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
59391 }
59392 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
59393 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
59394 }
59395 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
59396 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
59397 }
59398 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
59399 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
59400 }
59401 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
59402 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
59403 }
59404 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
59405 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
59406 }
59407 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
59408 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
59409 }
59410 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
59411 return (void *)((wxEvent *) ((wxFocusEvent *) x));
59412 }
59413 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
59414 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
59415 }
59416 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
59417 return (void *)((wxEvent *) ((wxShowEvent *) x));
59418 }
59419 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
59420 return (void *)((wxEvent *) ((wxCommandEvent *) x));
59421 }
59422 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
59423 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
59424 }
59425 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
59426 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
59427 }
59428 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
59429 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
59430 }
59431 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
59432 return (void *)((wxEvent *) ((wxKeyEvent *) x));
59433 }
59434 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
59435 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
59436 }
59437 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
59438 return (void *)((wxValidator *) ((wxPyValidator *) x));
59439 }
59440 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
59441 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
59442 }
59443 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
59444 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
59445 }
59446 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
59447 return (void *)((wxObject *) ((wxSizerItem *) x));
59448 }
59449 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
59450 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
59451 }
59452 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
59453 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
59454 }
59455 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
59456 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
59457 }
59458 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
59459 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
59460 }
59461 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
59462 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
59463 }
59464 static void *_p_wxSizerTo_p_wxObject(void *x) {
59465 return (void *)((wxObject *) ((wxSizer *) x));
59466 }
59467 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
59468 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
59469 }
59470 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
59471 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
59472 }
59473 static void *_p_wxEventTo_p_wxObject(void *x) {
59474 return (void *)((wxObject *) ((wxEvent *) x));
59475 }
59476 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
59477 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
59478 }
59479 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
59480 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
59481 }
59482 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
59483 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
59484 }
59485 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
59486 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
59487 }
59488 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
59489 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
59490 }
59491 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
59492 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
59493 }
59494 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
59495 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
59496 }
59497 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
59498 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
59499 }
59500 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
59501 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
59502 }
59503 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
59504 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
59505 }
59506 static void *_p_wxControlTo_p_wxObject(void *x) {
59507 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
59508 }
59509 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
59510 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
59511 }
59512 static void *_p_wxFSFileTo_p_wxObject(void *x) {
59513 return (void *)((wxObject *) ((wxFSFile *) x));
59514 }
59515 static void *_p_wxPySizerTo_p_wxObject(void *x) {
59516 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
59517 }
59518 static void *_p_wxPyEventTo_p_wxObject(void *x) {
59519 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
59520 }
59521 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
59522 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
59523 }
59524 static void *_p_wxShowEventTo_p_wxObject(void *x) {
59525 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
59526 }
59527 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
59528 return (void *)((wxObject *) ((wxMenuItem *) x));
59529 }
59530 static void *_p_wxDateEventTo_p_wxObject(void *x) {
59531 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
59532 }
59533 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
59534 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
59535 }
59536 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
59537 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
59538 }
59539 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
59540 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
59541 }
59542 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
59543 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
59544 }
59545 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
59546 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
59547 }
59548 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
59549 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
59550 }
59551 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
59552 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
59553 }
59554 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
59555 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
59556 }
59557 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
59558 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
59559 }
59560 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
59561 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
59562 }
59563 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
59564 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
59565 }
59566 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
59567 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
59568 }
59569 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
59570 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
59571 }
59572 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
59573 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
59574 }
59575 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
59576 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
59577 }
59578 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
59579 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
59580 }
59581 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
59582 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
59583 }
59584 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
59585 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
59586 }
59587 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
59588 return (void *)((wxObject *) ((wxImageHandler *) x));
59589 }
59590 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
59591 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
59592 }
59593 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
59594 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
59595 }
59596 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
59597 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
59598 }
59599 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
59600 return (void *)((wxObject *) ((wxEvtHandler *) x));
59601 }
59602 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
59603 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
59604 }
59605 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
59606 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
59607 }
59608 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
59609 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
59610 }
59611 static void *_p_wxImageTo_p_wxObject(void *x) {
59612 return (void *)((wxObject *) ((wxImage *) x));
59613 }
59614 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
59615 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
59616 }
59617 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
59618 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
59619 }
59620 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
59621 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
59622 }
59623 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
59624 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
59625 }
59626 static void *_p_wxWindowTo_p_wxObject(void *x) {
59627 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
59628 }
59629 static void *_p_wxMenuTo_p_wxObject(void *x) {
59630 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
59631 }
59632 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
59633 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
59634 }
59635 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
59636 return (void *)((wxObject *) ((wxFileSystem *) x));
59637 }
59638 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
59639 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
59640 }
59641 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
59642 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
59643 }
59644 static void *_p_wxPyAppTo_p_wxObject(void *x) {
59645 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
59646 }
59647 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
59648 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
59649 }
59650 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
59651 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
59652 }
59653 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
59654 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
59655 }
59656 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
59657 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
59658 }
59659 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
59660 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
59661 }
59662 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
59663 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
59664 }
59665 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
59666 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
59667 }
59668 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
59669 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
59670 }
59671 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
59672 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
59673 }
59674 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
59675 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
59676 }
59677 static void *_p_wxValidatorTo_p_wxObject(void *x) {
59678 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
59679 }
59680 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
59681 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
59682 }
59683 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
59684 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
59685 }
59686 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
59687 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
59688 }
59689 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
59690 return (void *)((wxControl *) ((wxControlWithItems *) x));
59691 }
59692 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
59693 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
59694 }
59695 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
59696 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
59697 }
59698 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
59699 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
59700 }
59701 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
59702 return (void *)((wxSizer *) ((wxBoxSizer *) x));
59703 }
59704 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
59705 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
59706 }
59707 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
59708 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
59709 }
59710 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
59711 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
59712 }
59713 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
59714 return (void *)((wxSizer *) ((wxGridSizer *) x));
59715 }
59716 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
59717 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
59718 }
59719 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
59720 return (void *)((wxSizer *) ((wxPySizer *) x));
59721 }
59722 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
59723 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
59724 }
59725 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
59726 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
59727 }
59728 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
59729 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
59730 }
59731 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
59732 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
59733 }
59734 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
59735 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
59736 }
59737 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
59738 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
59739 }
59740 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
59741 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
59742 }
59743 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
59744 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
59745 }
59746 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
59747 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
59748 }
59749 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
59750 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
59751 }
59752 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
59753 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
59754 }
59755 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
59756 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
59757 }
59758 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
59759 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
59760 }
59761 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
59762 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
59763 }
59764 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
59765 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
59766 }
59767 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
59768 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
59769 }
59770 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
59771 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
59772 }
59773 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
59774 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
59775 }
59776 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
59777 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
59778 }
59779 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
59780 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
59781 }
59782 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
59783 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
59784 }
59785 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
59786 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
59787 }
59788 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
59789 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
59790 }
59791 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
59792 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
59793 }
59794 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
59795 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
59796 }
59797 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
59798 return (void *)((wxEvtHandler *) ((wxWindow *) x));
59799 }
59800 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
59801 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
59802 }
59803 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
59804 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
59805 }
59806 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
59807 return (void *)((wxEvtHandler *) ((wxValidator *) x));
59808 }
59809 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
59810 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
59811 }
59812 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
59813 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
59814 }
59815 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
59816 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
59817 }
59818 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
59819 return (void *)((wxEvtHandler *) ((wxMenu *) x));
59820 }
59821 static void *_p_wxControlTo_p_wxWindow(void *x) {
59822 return (void *)((wxWindow *) ((wxControl *) x));
59823 }
59824 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
59825 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
59826 }
59827 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
59828 return (void *)((wxWindow *) ((wxMenuBar *) x));
59829 }
59830 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
59831 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
59832 }
59833 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
59834 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
59835 }
59836 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
59837 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
59838 }
59839 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
59840 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
59841 }
59842 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
59843 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
59844 }
59845 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
59846 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
59847 }
59848 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
59849 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
59850 }
59851 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
59852 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
59853 }
59854 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
59855 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
59856 }
59857 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
59858 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
59859 }
59860 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
59861 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
59862 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};
59863 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
59864 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
59865 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
59866 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
59867 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
59868 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
59869 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
59870 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
59871 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
59872 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
59873 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
59874 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
59875 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
59876 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
59877 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
59878 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
59879 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
59880 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
59881 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
59882 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
59883 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
59884 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
59885 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
59886 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
59887 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
59888 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
59889 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
59890 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
59891 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
59892 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
59893 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
59894 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
59895 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
59896 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
59897 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
59898 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", "wxEventBlocker *", 0, 0, (void*)0, 0};
59899 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
59900 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
59901 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
59902 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
59903 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
59904 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
59905 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
59906 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
59907 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
59908 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
59909 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
59910 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
59911 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
59912 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
59913 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
59914 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
59915 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
59916 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
59917 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
59918 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
59919 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
59920 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
59921 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
59922 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
59923 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
59924 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
59925 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
59926 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
59927 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
59928 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
59929 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
59930 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
59931 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
59932 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
59933 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
59934 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
59935 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
59936 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
59937 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
59938 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
59939 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
59940 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
59941 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
59942 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
59943 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
59944 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
59945 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
59946 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
59947 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
59948 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
59949 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
59950 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
59951 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
59952 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
59953 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
59954 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
59955 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
59956 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
59957 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
59958 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
59959 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
59960 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
59961 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
59962 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
59963 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
59964 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
59965 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
59966 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
59967 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
59968 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
59969 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
59970 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
59971 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
59972 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
59973 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
59974 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
59975 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
59976 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
59977 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
59978 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
59979 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
59980 static swig_type_info _swigt__p_wxSizerFlags = {"_p_wxSizerFlags", "wxSizerFlags *", 0, 0, (void*)0, 0};
59981 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
59982 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
59983 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
59984 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
59985 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
59986 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
59987 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
59988 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
59989 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
59990 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
59991 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
59992 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
59993 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
59994 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
59995 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
59996 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
59997
59998 static swig_type_info *swig_type_initial[] = {
59999 &_swigt__p_buffer,
60000 &_swigt__p_char,
60001 &_swigt__p_form_ops_t,
60002 &_swigt__p_int,
60003 &_swigt__p_long,
60004 &_swigt__p_unsigned_char,
60005 &_swigt__p_unsigned_int,
60006 &_swigt__p_unsigned_long,
60007 &_swigt__p_wxANIHandler,
60008 &_swigt__p_wxAcceleratorEntry,
60009 &_swigt__p_wxAcceleratorTable,
60010 &_swigt__p_wxActivateEvent,
60011 &_swigt__p_wxAppTraits,
60012 &_swigt__p_wxArrayString,
60013 &_swigt__p_wxBMPHandler,
60014 &_swigt__p_wxBitmap,
60015 &_swigt__p_wxBoxSizer,
60016 &_swigt__p_wxButton,
60017 &_swigt__p_wxCURHandler,
60018 &_swigt__p_wxCaret,
60019 &_swigt__p_wxChildFocusEvent,
60020 &_swigt__p_wxClipboardTextEvent,
60021 &_swigt__p_wxCloseEvent,
60022 &_swigt__p_wxColour,
60023 &_swigt__p_wxCommandEvent,
60024 &_swigt__p_wxContextMenuEvent,
60025 &_swigt__p_wxControl,
60026 &_swigt__p_wxControlWithItems,
60027 &_swigt__p_wxCursor,
60028 &_swigt__p_wxDC,
60029 &_swigt__p_wxDateEvent,
60030 &_swigt__p_wxDateTime,
60031 &_swigt__p_wxDisplayChangedEvent,
60032 &_swigt__p_wxDouble,
60033 &_swigt__p_wxDropFilesEvent,
60034 &_swigt__p_wxDuplexMode,
60035 &_swigt__p_wxEraseEvent,
60036 &_swigt__p_wxEvent,
60037 &_swigt__p_wxEventBlocker,
60038 &_swigt__p_wxEventLoop,
60039 &_swigt__p_wxEventLoopActivator,
60040 &_swigt__p_wxEvtHandler,
60041 &_swigt__p_wxFSFile,
60042 &_swigt__p_wxFileSystem,
60043 &_swigt__p_wxFileSystemHandler,
60044 &_swigt__p_wxFlexGridSizer,
60045 &_swigt__p_wxFocusEvent,
60046 &_swigt__p_wxFont,
60047 &_swigt__p_wxFrame,
60048 &_swigt__p_wxGBPosition,
60049 &_swigt__p_wxGBSizerItem,
60050 &_swigt__p_wxGBSpan,
60051 &_swigt__p_wxGIFHandler,
60052 &_swigt__p_wxGridBagSizer,
60053 &_swigt__p_wxGridSizer,
60054 &_swigt__p_wxHelpEvent__Origin,
60055 &_swigt__p_wxICOHandler,
60056 &_swigt__p_wxIconizeEvent,
60057 &_swigt__p_wxIdleEvent,
60058 &_swigt__p_wxImage,
60059 &_swigt__p_wxImageHandler,
60060 &_swigt__p_wxImageHistogram,
60061 &_swigt__p_wxImage_HSVValue,
60062 &_swigt__p_wxImage_RGBValue,
60063 &_swigt__p_wxIndividualLayoutConstraint,
60064 &_swigt__p_wxInitDialogEvent,
60065 &_swigt__p_wxInputStream,
60066 &_swigt__p_wxInternetFSHandler,
60067 &_swigt__p_wxItemContainer,
60068 &_swigt__p_wxJPEGHandler,
60069 &_swigt__p_wxKeyEvent,
60070 &_swigt__p_wxLayoutConstraints,
60071 &_swigt__p_wxMaximizeEvent,
60072 &_swigt__p_wxMemoryFSHandler,
60073 &_swigt__p_wxMenu,
60074 &_swigt__p_wxMenuBar,
60075 &_swigt__p_wxMenuBarBase,
60076 &_swigt__p_wxMenuEvent,
60077 &_swigt__p_wxMenuItem,
60078 &_swigt__p_wxMouseCaptureChangedEvent,
60079 &_swigt__p_wxMouseCaptureLostEvent,
60080 &_swigt__p_wxMouseEvent,
60081 &_swigt__p_wxMoveEvent,
60082 &_swigt__p_wxNavigationKeyEvent,
60083 &_swigt__p_wxNcPaintEvent,
60084 &_swigt__p_wxNotifyEvent,
60085 &_swigt__p_wxObject,
60086 &_swigt__p_wxOutputStream,
60087 &_swigt__p_wxPCXHandler,
60088 &_swigt__p_wxPNGHandler,
60089 &_swigt__p_wxPNMHandler,
60090 &_swigt__p_wxPaintEvent,
60091 &_swigt__p_wxPaletteChangedEvent,
60092 &_swigt__p_wxPaperSize,
60093 &_swigt__p_wxPoint,
60094 &_swigt__p_wxPoint2D,
60095 &_swigt__p_wxPropagateOnce,
60096 &_swigt__p_wxPropagationDisabler,
60097 &_swigt__p_wxPyApp,
60098 &_swigt__p_wxPyCommandEvent,
60099 &_swigt__p_wxPyDropTarget,
60100 &_swigt__p_wxPyEvent,
60101 &_swigt__p_wxPyFileSystemHandler,
60102 &_swigt__p_wxPyImageHandler,
60103 &_swigt__p_wxPyInputStream,
60104 &_swigt__p_wxPySizer,
60105 &_swigt__p_wxPyValidator,
60106 &_swigt__p_wxQuantize,
60107 &_swigt__p_wxQueryNewPaletteEvent,
60108 &_swigt__p_wxRealPoint,
60109 &_swigt__p_wxRect,
60110 &_swigt__p_wxRect2D,
60111 &_swigt__p_wxRegion,
60112 &_swigt__p_wxScrollEvent,
60113 &_swigt__p_wxScrollWinEvent,
60114 &_swigt__p_wxSetCursorEvent,
60115 &_swigt__p_wxShowEvent,
60116 &_swigt__p_wxSize,
60117 &_swigt__p_wxSizeEvent,
60118 &_swigt__p_wxSizer,
60119 &_swigt__p_wxSizerFlags,
60120 &_swigt__p_wxSizerItem,
60121 &_swigt__p_wxStaticBox,
60122 &_swigt__p_wxStaticBoxSizer,
60123 &_swigt__p_wxStdDialogButtonSizer,
60124 &_swigt__p_wxSysColourChangedEvent,
60125 &_swigt__p_wxTGAHandler,
60126 &_swigt__p_wxTIFFHandler,
60127 &_swigt__p_wxToolTip,
60128 &_swigt__p_wxUpdateUIEvent,
60129 &_swigt__p_wxValidator,
60130 &_swigt__p_wxVisualAttributes,
60131 &_swigt__p_wxWindow,
60132 &_swigt__p_wxWindowCreateEvent,
60133 &_swigt__p_wxWindowDestroyEvent,
60134 &_swigt__p_wxXPMHandler,
60135 &_swigt__p_wxZipFSHandler,
60136 };
60137
60138 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
60139 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
60140 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
60141 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
60142 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
60143 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
60144 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
60145 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
60146 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
60147 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
60148 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
60149 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
60150 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
60151 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
60152 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}};
60153 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
60154 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}};
60155 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
60156 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}};
60157 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
60158 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60159 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
60160 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
60161 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
60162 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}};
60163 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60164 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}};
60165 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
60166 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
60167 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
60168 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
60169 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
60170 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60171 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
60172 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
60173 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
60174 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
60175 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}};
60176 static swig_cast_info _swigc__p_wxEventBlocker[] = { {&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
60177 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
60178 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
60179 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}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
60180 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
60181 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
60182 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}};
60183 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}};
60184 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60185 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
60186 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
60187 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
60188 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
60189 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
60190 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
60191 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
60192 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}};
60193 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
60194 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}};
60195 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60196 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
60197 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
60198 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}};
60199 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
60200 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
60201 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
60202 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
60203 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
60204 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
60205 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60206 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}};
60207 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
60208 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60209 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
60210 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60211 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60212 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
60213 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
60214 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
60215 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60216 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
60217 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60218 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
60219 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
60220 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
60221 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60222 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60223 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
60224 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_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_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_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_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_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}};
60225 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
60226 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
60227 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
60228 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
60229 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60230 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60231 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
60232 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
60233 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
60234 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
60235 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
60236 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
60237 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
60238 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
60239 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
60240 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
60241 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
60242 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
60243 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
60244 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
60245 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
60246 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
60247 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
60248 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
60249 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
60250 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
60251 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
60252 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
60253 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
60254 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
60255 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
60256 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60257 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}};
60258 static swig_cast_info _swigc__p_wxSizerFlags[] = { {&_swigt__p_wxSizerFlags, 0, 0, 0},{0, 0, 0, 0}};
60259 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}};
60260 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
60261 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
60262 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
60263 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60264 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
60265 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
60266 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
60267 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
60268 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}};
60269 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
60270 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}};
60271 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
60272 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
60273 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
60274 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60275
60276 static swig_cast_info *swig_cast_initial[] = {
60277 _swigc__p_buffer,
60278 _swigc__p_char,
60279 _swigc__p_form_ops_t,
60280 _swigc__p_int,
60281 _swigc__p_long,
60282 _swigc__p_unsigned_char,
60283 _swigc__p_unsigned_int,
60284 _swigc__p_unsigned_long,
60285 _swigc__p_wxANIHandler,
60286 _swigc__p_wxAcceleratorEntry,
60287 _swigc__p_wxAcceleratorTable,
60288 _swigc__p_wxActivateEvent,
60289 _swigc__p_wxAppTraits,
60290 _swigc__p_wxArrayString,
60291 _swigc__p_wxBMPHandler,
60292 _swigc__p_wxBitmap,
60293 _swigc__p_wxBoxSizer,
60294 _swigc__p_wxButton,
60295 _swigc__p_wxCURHandler,
60296 _swigc__p_wxCaret,
60297 _swigc__p_wxChildFocusEvent,
60298 _swigc__p_wxClipboardTextEvent,
60299 _swigc__p_wxCloseEvent,
60300 _swigc__p_wxColour,
60301 _swigc__p_wxCommandEvent,
60302 _swigc__p_wxContextMenuEvent,
60303 _swigc__p_wxControl,
60304 _swigc__p_wxControlWithItems,
60305 _swigc__p_wxCursor,
60306 _swigc__p_wxDC,
60307 _swigc__p_wxDateEvent,
60308 _swigc__p_wxDateTime,
60309 _swigc__p_wxDisplayChangedEvent,
60310 _swigc__p_wxDouble,
60311 _swigc__p_wxDropFilesEvent,
60312 _swigc__p_wxDuplexMode,
60313 _swigc__p_wxEraseEvent,
60314 _swigc__p_wxEvent,
60315 _swigc__p_wxEventBlocker,
60316 _swigc__p_wxEventLoop,
60317 _swigc__p_wxEventLoopActivator,
60318 _swigc__p_wxEvtHandler,
60319 _swigc__p_wxFSFile,
60320 _swigc__p_wxFileSystem,
60321 _swigc__p_wxFileSystemHandler,
60322 _swigc__p_wxFlexGridSizer,
60323 _swigc__p_wxFocusEvent,
60324 _swigc__p_wxFont,
60325 _swigc__p_wxFrame,
60326 _swigc__p_wxGBPosition,
60327 _swigc__p_wxGBSizerItem,
60328 _swigc__p_wxGBSpan,
60329 _swigc__p_wxGIFHandler,
60330 _swigc__p_wxGridBagSizer,
60331 _swigc__p_wxGridSizer,
60332 _swigc__p_wxHelpEvent__Origin,
60333 _swigc__p_wxICOHandler,
60334 _swigc__p_wxIconizeEvent,
60335 _swigc__p_wxIdleEvent,
60336 _swigc__p_wxImage,
60337 _swigc__p_wxImageHandler,
60338 _swigc__p_wxImageHistogram,
60339 _swigc__p_wxImage_HSVValue,
60340 _swigc__p_wxImage_RGBValue,
60341 _swigc__p_wxIndividualLayoutConstraint,
60342 _swigc__p_wxInitDialogEvent,
60343 _swigc__p_wxInputStream,
60344 _swigc__p_wxInternetFSHandler,
60345 _swigc__p_wxItemContainer,
60346 _swigc__p_wxJPEGHandler,
60347 _swigc__p_wxKeyEvent,
60348 _swigc__p_wxLayoutConstraints,
60349 _swigc__p_wxMaximizeEvent,
60350 _swigc__p_wxMemoryFSHandler,
60351 _swigc__p_wxMenu,
60352 _swigc__p_wxMenuBar,
60353 _swigc__p_wxMenuBarBase,
60354 _swigc__p_wxMenuEvent,
60355 _swigc__p_wxMenuItem,
60356 _swigc__p_wxMouseCaptureChangedEvent,
60357 _swigc__p_wxMouseCaptureLostEvent,
60358 _swigc__p_wxMouseEvent,
60359 _swigc__p_wxMoveEvent,
60360 _swigc__p_wxNavigationKeyEvent,
60361 _swigc__p_wxNcPaintEvent,
60362 _swigc__p_wxNotifyEvent,
60363 _swigc__p_wxObject,
60364 _swigc__p_wxOutputStream,
60365 _swigc__p_wxPCXHandler,
60366 _swigc__p_wxPNGHandler,
60367 _swigc__p_wxPNMHandler,
60368 _swigc__p_wxPaintEvent,
60369 _swigc__p_wxPaletteChangedEvent,
60370 _swigc__p_wxPaperSize,
60371 _swigc__p_wxPoint,
60372 _swigc__p_wxPoint2D,
60373 _swigc__p_wxPropagateOnce,
60374 _swigc__p_wxPropagationDisabler,
60375 _swigc__p_wxPyApp,
60376 _swigc__p_wxPyCommandEvent,
60377 _swigc__p_wxPyDropTarget,
60378 _swigc__p_wxPyEvent,
60379 _swigc__p_wxPyFileSystemHandler,
60380 _swigc__p_wxPyImageHandler,
60381 _swigc__p_wxPyInputStream,
60382 _swigc__p_wxPySizer,
60383 _swigc__p_wxPyValidator,
60384 _swigc__p_wxQuantize,
60385 _swigc__p_wxQueryNewPaletteEvent,
60386 _swigc__p_wxRealPoint,
60387 _swigc__p_wxRect,
60388 _swigc__p_wxRect2D,
60389 _swigc__p_wxRegion,
60390 _swigc__p_wxScrollEvent,
60391 _swigc__p_wxScrollWinEvent,
60392 _swigc__p_wxSetCursorEvent,
60393 _swigc__p_wxShowEvent,
60394 _swigc__p_wxSize,
60395 _swigc__p_wxSizeEvent,
60396 _swigc__p_wxSizer,
60397 _swigc__p_wxSizerFlags,
60398 _swigc__p_wxSizerItem,
60399 _swigc__p_wxStaticBox,
60400 _swigc__p_wxStaticBoxSizer,
60401 _swigc__p_wxStdDialogButtonSizer,
60402 _swigc__p_wxSysColourChangedEvent,
60403 _swigc__p_wxTGAHandler,
60404 _swigc__p_wxTIFFHandler,
60405 _swigc__p_wxToolTip,
60406 _swigc__p_wxUpdateUIEvent,
60407 _swigc__p_wxValidator,
60408 _swigc__p_wxVisualAttributes,
60409 _swigc__p_wxWindow,
60410 _swigc__p_wxWindowCreateEvent,
60411 _swigc__p_wxWindowDestroyEvent,
60412 _swigc__p_wxXPMHandler,
60413 _swigc__p_wxZipFSHandler,
60414 };
60415
60416
60417 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
60418
60419 static swig_const_info swig_const_table[] = {
60420 {0, 0, 0, 0.0, 0, 0}};
60421
60422 #ifdef __cplusplus
60423 }
60424 #endif
60425 /* -----------------------------------------------------------------------------
60426 * Type initialization:
60427 * This problem is tough by the requirement that no dynamic
60428 * memory is used. Also, since swig_type_info structures store pointers to
60429 * swig_cast_info structures and swig_cast_info structures store pointers back
60430 * to swig_type_info structures, we need some lookup code at initialization.
60431 * The idea is that swig generates all the structures that are needed.
60432 * The runtime then collects these partially filled structures.
60433 * The SWIG_InitializeModule function takes these initial arrays out of
60434 * swig_module, and does all the lookup, filling in the swig_module.types
60435 * array with the correct data and linking the correct swig_cast_info
60436 * structures together.
60437 *
60438 * The generated swig_type_info structures are assigned staticly to an initial
60439 * array. We just loop though that array, and handle each type individually.
60440 * First we lookup if this type has been already loaded, and if so, use the
60441 * loaded structure instead of the generated one. Then we have to fill in the
60442 * cast linked list. The cast data is initially stored in something like a
60443 * two-dimensional array. Each row corresponds to a type (there are the same
60444 * number of rows as there are in the swig_type_initial array). Each entry in
60445 * a column is one of the swig_cast_info structures for that type.
60446 * The cast_initial array is actually an array of arrays, because each row has
60447 * a variable number of columns. So to actually build the cast linked list,
60448 * we find the array of casts associated with the type, and loop through it
60449 * adding the casts to the list. The one last trick we need to do is making
60450 * sure the type pointer in the swig_cast_info struct is correct.
60451 *
60452 * First off, we lookup the cast->type name to see if it is already loaded.
60453 * There are three cases to handle:
60454 * 1) If the cast->type has already been loaded AND the type we are adding
60455 * casting info to has not been loaded (it is in this module), THEN we
60456 * replace the cast->type pointer with the type pointer that has already
60457 * been loaded.
60458 * 2) If BOTH types (the one we are adding casting info to, and the
60459 * cast->type) are loaded, THEN the cast info has already been loaded by
60460 * the previous module so we just ignore it.
60461 * 3) Finally, if cast->type has not already been loaded, then we add that
60462 * swig_cast_info to the linked list (because the cast->type) pointer will
60463 * be correct.
60464 * ----------------------------------------------------------------------------- */
60465
60466 #ifdef __cplusplus
60467 extern "C" {
60468 #if 0
60469 } /* c-mode */
60470 #endif
60471 #endif
60472
60473 #if 0
60474 #define SWIGRUNTIME_DEBUG
60475 #endif
60476
60477 SWIGRUNTIME void
60478 SWIG_InitializeModule(void *clientdata) {
60479 size_t i;
60480 swig_module_info *module_head;
60481 static int init_run = 0;
60482
60483 clientdata = clientdata;
60484
60485 if (init_run) return;
60486 init_run = 1;
60487
60488 /* Initialize the swig_module */
60489 swig_module.type_initial = swig_type_initial;
60490 swig_module.cast_initial = swig_cast_initial;
60491
60492 /* Try and load any already created modules */
60493 module_head = SWIG_GetModule(clientdata);
60494 if (module_head) {
60495 swig_module.next = module_head->next;
60496 module_head->next = &swig_module;
60497 } else {
60498 /* This is the first module loaded */
60499 swig_module.next = &swig_module;
60500 SWIG_SetModule(clientdata, &swig_module);
60501 }
60502
60503 /* Now work on filling in swig_module.types */
60504 #ifdef SWIGRUNTIME_DEBUG
60505 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
60506 #endif
60507 for (i = 0; i < swig_module.size; ++i) {
60508 swig_type_info *type = 0;
60509 swig_type_info *ret;
60510 swig_cast_info *cast;
60511
60512 #ifdef SWIGRUNTIME_DEBUG
60513 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
60514 #endif
60515
60516 /* if there is another module already loaded */
60517 if (swig_module.next != &swig_module) {
60518 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
60519 }
60520 if (type) {
60521 /* Overwrite clientdata field */
60522 #ifdef SWIGRUNTIME_DEBUG
60523 printf("SWIG_InitializeModule: found type %s\n", type->name);
60524 #endif
60525 if (swig_module.type_initial[i]->clientdata) {
60526 type->clientdata = swig_module.type_initial[i]->clientdata;
60527 #ifdef SWIGRUNTIME_DEBUG
60528 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
60529 #endif
60530 }
60531 } else {
60532 type = swig_module.type_initial[i];
60533 }
60534
60535 /* Insert casting types */
60536 cast = swig_module.cast_initial[i];
60537 while (cast->type) {
60538 /* Don't need to add information already in the list */
60539 ret = 0;
60540 #ifdef SWIGRUNTIME_DEBUG
60541 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
60542 #endif
60543 if (swig_module.next != &swig_module) {
60544 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
60545 #ifdef SWIGRUNTIME_DEBUG
60546 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
60547 #endif
60548 }
60549 if (ret) {
60550 if (type == swig_module.type_initial[i]) {
60551 #ifdef SWIGRUNTIME_DEBUG
60552 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
60553 #endif
60554 cast->type = ret;
60555 ret = 0;
60556 } else {
60557 /* Check for casting already in the list */
60558 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
60559 #ifdef SWIGRUNTIME_DEBUG
60560 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
60561 #endif
60562 if (!ocast) ret = 0;
60563 }
60564 }
60565
60566 if (!ret) {
60567 #ifdef SWIGRUNTIME_DEBUG
60568 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
60569 #endif
60570 if (type->cast) {
60571 type->cast->prev = cast;
60572 cast->next = type->cast;
60573 }
60574 type->cast = cast;
60575 }
60576 cast++;
60577 }
60578 /* Set entry in modules->types array equal to the type */
60579 swig_module.types[i] = type;
60580 }
60581 swig_module.types[i] = 0;
60582
60583 #ifdef SWIGRUNTIME_DEBUG
60584 printf("**** SWIG_InitializeModule: Cast List ******\n");
60585 for (i = 0; i < swig_module.size; ++i) {
60586 int j = 0;
60587 swig_cast_info *cast = swig_module.cast_initial[i];
60588 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
60589 while (cast->type) {
60590 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
60591 cast++;
60592 ++j;
60593 }
60594 printf("---- Total casts: %d\n",j);
60595 }
60596 printf("**** SWIG_InitializeModule: Cast List ******\n");
60597 #endif
60598 }
60599
60600 /* This function will propagate the clientdata field of type to
60601 * any new swig_type_info structures that have been added into the list
60602 * of equivalent types. It is like calling
60603 * SWIG_TypeClientData(type, clientdata) a second time.
60604 */
60605 SWIGRUNTIME void
60606 SWIG_PropagateClientData(void) {
60607 size_t i;
60608 swig_cast_info *equiv;
60609 static int init_run = 0;
60610
60611 if (init_run) return;
60612 init_run = 1;
60613
60614 for (i = 0; i < swig_module.size; i++) {
60615 if (swig_module.types[i]->clientdata) {
60616 equiv = swig_module.types[i]->cast;
60617 while (equiv) {
60618 if (!equiv->converter) {
60619 if (equiv->type && !equiv->type->clientdata)
60620 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
60621 }
60622 equiv = equiv->next;
60623 }
60624 }
60625 }
60626 }
60627
60628 #ifdef __cplusplus
60629 #if 0
60630 {
60631 /* c-mode */
60632 #endif
60633 }
60634 #endif
60635
60636
60637
60638 #ifdef __cplusplus
60639 extern "C" {
60640 #endif
60641
60642 /* Python-specific SWIG API */
60643 #define SWIG_newvarlink() SWIG_Python_newvarlink()
60644 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
60645 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
60646
60647 /* -----------------------------------------------------------------------------
60648 * global variable support code.
60649 * ----------------------------------------------------------------------------- */
60650
60651 typedef struct swig_globalvar {
60652 char *name; /* Name of global variable */
60653 PyObject *(*get_attr)(void); /* Return the current value */
60654 int (*set_attr)(PyObject *); /* Set the value */
60655 struct swig_globalvar *next;
60656 } swig_globalvar;
60657
60658 typedef struct swig_varlinkobject {
60659 PyObject_HEAD
60660 swig_globalvar *vars;
60661 } swig_varlinkobject;
60662
60663 SWIGINTERN PyObject *
60664 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
60665 return PyString_FromString("<Swig global variables>");
60666 }
60667
60668 SWIGINTERN PyObject *
60669 swig_varlink_str(swig_varlinkobject *v) {
60670 PyObject *str = PyString_FromString("(");
60671 swig_globalvar *var;
60672 for (var = v->vars; var; var=var->next) {
60673 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
60674 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
60675 }
60676 PyString_ConcatAndDel(&str,PyString_FromString(")"));
60677 return str;
60678 }
60679
60680 SWIGINTERN int
60681 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
60682 PyObject *str = swig_varlink_str(v);
60683 fprintf(fp,"Swig global variables ");
60684 fprintf(fp,"%s\n", PyString_AsString(str));
60685 Py_DECREF(str);
60686 return 0;
60687 }
60688
60689 SWIGINTERN void
60690 swig_varlink_dealloc(swig_varlinkobject *v) {
60691 swig_globalvar *var = v->vars;
60692 while (var) {
60693 swig_globalvar *n = var->next;
60694 free(var->name);
60695 free(var);
60696 var = n;
60697 }
60698 }
60699
60700 SWIGINTERN PyObject *
60701 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
60702 PyObject *res = NULL;
60703 swig_globalvar *var = v->vars;
60704 while (var) {
60705 if (strcmp(var->name,n) == 0) {
60706 res = (*var->get_attr)();
60707 break;
60708 }
60709 var = var->next;
60710 }
60711 if (res == NULL && !PyErr_Occurred()) {
60712 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
60713 }
60714 return res;
60715 }
60716
60717 SWIGINTERN int
60718 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
60719 int res = 1;
60720 swig_globalvar *var = v->vars;
60721 while (var) {
60722 if (strcmp(var->name,n) == 0) {
60723 res = (*var->set_attr)(p);
60724 break;
60725 }
60726 var = var->next;
60727 }
60728 if (res == 1 && !PyErr_Occurred()) {
60729 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
60730 }
60731 return res;
60732 }
60733
60734 SWIGINTERN PyTypeObject*
60735 swig_varlink_type(void) {
60736 static char varlink__doc__[] = "Swig var link object";
60737 static PyTypeObject varlink_type;
60738 static int type_init = 0;
60739 if (!type_init) {
60740 const PyTypeObject tmp
60741 = {
60742 PyObject_HEAD_INIT(NULL)
60743 0, /* Number of items in variable part (ob_size) */
60744 (char *)"swigvarlink", /* Type name (tp_name) */
60745 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
60746 0, /* Itemsize (tp_itemsize) */
60747 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
60748 (printfunc) swig_varlink_print, /* Print (tp_print) */
60749 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
60750 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
60751 0, /* tp_compare */
60752 (reprfunc) swig_varlink_repr, /* tp_repr */
60753 0, /* tp_as_number */
60754 0, /* tp_as_sequence */
60755 0, /* tp_as_mapping */
60756 0, /* tp_hash */
60757 0, /* tp_call */
60758 (reprfunc)swig_varlink_str, /* tp_str */
60759 0, /* tp_getattro */
60760 0, /* tp_setattro */
60761 0, /* tp_as_buffer */
60762 0, /* tp_flags */
60763 varlink__doc__, /* tp_doc */
60764 0, /* tp_traverse */
60765 0, /* tp_clear */
60766 0, /* tp_richcompare */
60767 0, /* tp_weaklistoffset */
60768 #if PY_VERSION_HEX >= 0x02020000
60769 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
60770 #endif
60771 #if PY_VERSION_HEX >= 0x02030000
60772 0, /* tp_del */
60773 #endif
60774 #ifdef COUNT_ALLOCS
60775 0,0,0,0 /* tp_alloc -> tp_next */
60776 #endif
60777 };
60778 varlink_type = tmp;
60779 varlink_type.ob_type = &PyType_Type;
60780 type_init = 1;
60781 }
60782 return &varlink_type;
60783 }
60784
60785 /* Create a variable linking object for use later */
60786 SWIGINTERN PyObject *
60787 SWIG_Python_newvarlink(void) {
60788 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
60789 if (result) {
60790 result->vars = 0;
60791 }
60792 return ((PyObject*) result);
60793 }
60794
60795 SWIGINTERN void
60796 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
60797 swig_varlinkobject *v = (swig_varlinkobject *) p;
60798 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
60799 if (gv) {
60800 size_t size = strlen(name)+1;
60801 gv->name = (char *)malloc(size);
60802 if (gv->name) {
60803 strncpy(gv->name,name,size);
60804 gv->get_attr = get_attr;
60805 gv->set_attr = set_attr;
60806 gv->next = v->vars;
60807 }
60808 }
60809 v->vars = gv;
60810 }
60811
60812 SWIGINTERN PyObject *
60813 SWIG_globals() {
60814 static PyObject *_SWIG_globals = 0;
60815 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
60816 return _SWIG_globals;
60817 }
60818
60819 /* -----------------------------------------------------------------------------
60820 * constants/methods manipulation
60821 * ----------------------------------------------------------------------------- */
60822
60823 /* Install Constants */
60824 SWIGINTERN void
60825 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
60826 PyObject *obj = 0;
60827 size_t i;
60828 for (i = 0; constants[i].type; ++i) {
60829 switch(constants[i].type) {
60830 case SWIG_PY_POINTER:
60831 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
60832 break;
60833 case SWIG_PY_BINARY:
60834 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
60835 break;
60836 default:
60837 obj = 0;
60838 break;
60839 }
60840 if (obj) {
60841 PyDict_SetItemString(d, constants[i].name, obj);
60842 Py_DECREF(obj);
60843 }
60844 }
60845 }
60846
60847 /* -----------------------------------------------------------------------------*/
60848 /* Fix SwigMethods to carry the callback ptrs when needed */
60849 /* -----------------------------------------------------------------------------*/
60850
60851 SWIGINTERN void
60852 SWIG_Python_FixMethods(PyMethodDef *methods,
60853 swig_const_info *const_table,
60854 swig_type_info **types,
60855 swig_type_info **types_initial) {
60856 size_t i;
60857 for (i = 0; methods[i].ml_name; ++i) {
60858 const char *c = methods[i].ml_doc;
60859 if (c && (c = strstr(c, "swig_ptr: "))) {
60860 int j;
60861 swig_const_info *ci = 0;
60862 const char *name = c + 10;
60863 for (j = 0; const_table[j].type; ++j) {
60864 if (strncmp(const_table[j].name, name,
60865 strlen(const_table[j].name)) == 0) {
60866 ci = &(const_table[j]);
60867 break;
60868 }
60869 }
60870 if (ci) {
60871 size_t shift = (ci->ptype) - types;
60872 swig_type_info *ty = types_initial[shift];
60873 size_t ldoc = (c - methods[i].ml_doc);
60874 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
60875 char *ndoc = (char*)malloc(ldoc + lptr + 10);
60876 if (ndoc) {
60877 char *buff = ndoc;
60878 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
60879 if (ptr) {
60880 strncpy(buff, methods[i].ml_doc, ldoc);
60881 buff += ldoc;
60882 strncpy(buff, "swig_ptr: ", 10);
60883 buff += 10;
60884 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
60885 methods[i].ml_doc = ndoc;
60886 }
60887 }
60888 }
60889 }
60890 }
60891 }
60892
60893 #ifdef __cplusplus
60894 }
60895 #endif
60896
60897 /* -----------------------------------------------------------------------------*
60898 * Partial Init method
60899 * -----------------------------------------------------------------------------*/
60900
60901 #ifdef __cplusplus
60902 extern "C"
60903 #endif
60904 SWIGEXPORT void SWIG_init(void) {
60905 PyObject *m, *d;
60906
60907 /* Fix SwigMethods to carry the callback ptrs when needed */
60908 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
60909
60910 m = Py_InitModule((char *) SWIG_name, SwigMethods);
60911 d = PyModule_GetDict(m);
60912
60913 SWIG_InitializeModule(0);
60914 SWIG_InstallConstants(d,swig_const_table);
60915
60916
60917
60918 #ifndef wxPyUSE_EXPORT
60919 // Make our API structure a CObject so other modules can import it
60920 // from this module.
60921 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
60922 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
60923 Py_XDECREF(cobj);
60924 #endif
60925
60926 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
60927 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
60928 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
60929 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
60930 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
60931 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
60932 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
60933 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
60934 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
60935 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
60936 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
60937 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
60938 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
60939 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
60940 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
60941 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
60942 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
60943 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
60944 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
60945 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
60946 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
60947 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
60948 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
60949 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
60950 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
60951 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
60952 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
60953 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
60954 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
60955 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
60956 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
60957 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
60958 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
60959 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
60960 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
60961 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
60962 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
60963 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
60964 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
60965 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
60966 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
60967 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
60968 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
60969 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
60970 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
60971 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
60972 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
60973 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
60974 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
60975 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
60976 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
60977 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
60978 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
60979 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
60980 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
60981 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
60982 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
60983 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
60984 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
60985 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
60986 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
60987 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
60988 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
60989 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
60990 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
60991 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
60992 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
60993 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
60994 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
60995 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
60996 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
60997 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
60998 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
60999 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
61000 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
61001 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
61002 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
61003 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
61004 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
61005 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
61006 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
61007 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
61008 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
61009 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
61010 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
61011 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
61012 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
61013 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
61014 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
61015 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
61016 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
61017 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
61018 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
61019 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
61020 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
61021 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
61022 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
61023 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
61024 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
61025 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
61026 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
61027 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
61028 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
61029 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
61030 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
61031 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
61032 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
61033 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
61034 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
61035 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
61036 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
61037 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
61038 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
61039 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
61040 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
61041 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
61042 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
61043 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
61044 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
61045 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
61046 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
61047 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
61048 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
61049 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
61050 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
61051 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
61052 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
61053 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
61054 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
61055 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
61056 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
61057 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
61058 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
61059 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
61060 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
61061 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
61062 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
61063 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
61064 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
61065 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
61066 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
61067 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
61068 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
61069 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
61070 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
61071 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
61072 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
61073 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
61074 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
61075 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
61076 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
61077 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
61078 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
61079 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
61080 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
61081 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
61082 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
61083 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
61084 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
61085 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
61086 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
61087 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
61088 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
61089 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
61090 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
61091 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
61092 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
61093 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
61094 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
61095 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
61096 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
61097 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
61098 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
61099 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
61100 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
61101 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
61102 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
61103 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
61104 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
61105 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
61106 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
61107 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
61108 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
61109 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
61110 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
61111 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
61112 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
61113 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
61114 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
61115 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
61116 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
61117 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
61118 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
61119 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
61120 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
61121 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
61122 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
61123 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
61124 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
61125 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
61126 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
61127 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
61128 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
61129 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
61130 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
61131 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
61132 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
61133 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
61134 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
61135 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
61136 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
61137 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
61138 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
61139 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
61140 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
61141 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
61142 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
61143 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
61144 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
61145 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
61146 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
61147 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
61148 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
61149 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
61150 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
61151 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
61152 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
61153 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
61154 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
61155 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
61156 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
61157 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
61158 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
61159 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
61160 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
61161 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
61162 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
61163 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
61164 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
61165 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
61166 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
61167 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
61168 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
61169 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
61170 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
61171 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
61172 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
61173 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
61174 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
61175 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
61176 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
61177 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
61178 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
61179 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
61180 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
61181 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
61182 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
61183 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
61184 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
61185 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
61186 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
61187 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
61188 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
61189 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
61190 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
61191 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
61192 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
61193 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
61194 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
61195 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
61196 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
61197 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
61198 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
61199 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
61200 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
61201 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
61202 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
61203 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
61204 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
61205 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
61206 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
61207 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
61208 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
61209 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
61210 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
61211 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
61212 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
61213 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
61214 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
61215 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
61216 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
61217 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
61218 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
61219 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
61220 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
61221 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
61222 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
61223 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
61224 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
61225 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
61226 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
61227 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
61228 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
61229 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
61230 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
61231 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
61232 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
61233 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
61234 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
61235 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
61236 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
61237 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
61238 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
61239 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
61240 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
61241 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
61242 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
61243 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
61244 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
61245 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
61246 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
61247 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
61248 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
61249 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
61250 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
61251 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
61252 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
61253 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
61254 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
61255 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
61256 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
61257 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
61258 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
61259 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
61260 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
61261 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
61262 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
61263 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
61264 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
61265 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
61266 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
61267 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
61268 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
61269 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
61270 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
61271 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
61272 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
61273 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
61274 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
61275 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
61276 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
61277 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
61278 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
61279 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
61280 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
61281 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
61282 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
61283 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
61284 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
61285 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
61286 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
61287 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
61288 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
61289 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
61290 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
61291 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
61292 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
61293 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
61294 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
61295 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
61296 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
61297 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
61298 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
61299 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
61300 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
61301 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
61302 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
61303 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
61304 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
61305 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
61306 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
61307 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
61308 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
61309 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
61310 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
61311 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
61312 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
61313 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
61314 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
61315 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
61316 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
61317 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
61318 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
61319 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
61320 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
61321 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
61322 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
61323 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
61324 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
61325 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
61326 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
61327 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
61328 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
61329 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
61330 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
61331 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
61332 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
61333 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
61334 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
61335 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
61336 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
61337 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
61338 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
61339 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
61340 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
61341 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
61342 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
61343 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
61344 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
61345 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
61346 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
61347 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
61348 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
61349 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
61350 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
61351 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
61352 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
61353 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
61354 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
61355 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
61356 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
61357 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
61358 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
61359 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
61360 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
61361 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
61362 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
61363 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
61364 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
61365 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
61366 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
61367 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
61368 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
61369 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
61370 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
61371 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
61372 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
61373 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
61374 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
61375 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
61376 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
61377 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
61378 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
61379 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
61380 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
61381 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
61382 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
61383 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
61384 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
61385 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
61386 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
61387 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
61388 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
61389 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
61390 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
61391 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
61392 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
61393 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
61394 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
61395 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
61396 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
61397 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
61398 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
61399 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
61400 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
61401 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
61402 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
61403 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
61404 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
61405 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
61406 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
61407 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
61408 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
61409 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
61410 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
61411 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
61412 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
61413 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
61414 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
61415 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
61416 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
61417 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
61418 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
61419 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
61420 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
61421 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
61422 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
61423 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
61424 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
61425 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
61426 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
61427 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
61428 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
61429 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
61430 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
61431 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
61432 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
61433 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
61434 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
61435 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
61436 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
61437 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
61438 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
61439 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
61440 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
61441 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
61442 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
61443 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
61444 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
61445 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
61446 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
61447 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
61448 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
61449 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
61450 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
61451 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
61452 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
61453 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
61454 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
61455 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
61456 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
61457 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
61458 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
61459 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
61460 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
61461 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
61462 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
61463 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
61464 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
61465 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
61466 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
61467 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
61468 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
61469 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
61470 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
61471 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
61472 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
61473 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
61474 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
61475 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
61476 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
61477 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
61478 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
61479 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
61480 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
61481 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
61482 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
61483 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
61484 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
61485 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
61486 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
61487 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
61488 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
61489 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
61490 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
61491 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
61492 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
61493 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
61494 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
61495 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
61496 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
61497 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
61498 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
61499 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
61500 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
61501 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
61502 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
61503 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
61504 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
61505 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
61506 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
61507 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
61508 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
61509 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
61510 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
61511 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
61512 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
61513 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
61514 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
61515 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
61516 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
61517 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
61518 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
61519 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
61520 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
61521 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
61522 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
61523 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
61524 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
61525 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
61526 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
61527 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
61528 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
61529 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
61530 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
61531 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
61532 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
61533 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
61534 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
61535 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
61536 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
61537 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
61538 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
61539 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
61540 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
61541 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
61542 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
61543 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
61544 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
61545 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
61546 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
61547 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
61548 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
61549 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
61550 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
61551 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
61552 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
61553 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
61554 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
61555 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
61556 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
61557 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
61558 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
61559 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
61560 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
61561 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
61562 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
61563 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
61564 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
61565 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
61566 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
61567 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
61568 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
61569 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
61570 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
61571 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
61572 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
61573 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
61574 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
61575 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
61576 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
61577 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
61578 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
61579 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
61580 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
61581 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
61582 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
61583 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
61584
61585 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
61586
61587
61588 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
61589
61590 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
61591 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
61592 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
61593 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
61594 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
61595 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
61596 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
61597 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
61598 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
61599 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
61600 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
61601 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
61602 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
61603 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
61604 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
61605 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
61606 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
61607 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
61608 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
61609 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
61610 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
61611 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
61612 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
61613 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
61614 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
61615 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
61616 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
61617 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
61618 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
61619 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
61620 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
61621 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
61622 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
61623 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
61624 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
61625 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
61626 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
61627 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
61628 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
61629 PyDict_SetItemString(d, "wxEVT_ANY", PyInt_FromLong(wxEVT_ANY));
61630 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
61631 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
61632 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
61633 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
61634 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
61635 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
61636 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
61637 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
61638 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
61639 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
61640 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
61641 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
61642 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
61643 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
61644 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
61645 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
61646 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
61647 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
61648 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
61649 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
61650 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
61651 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
61652 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
61653 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
61654 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
61655 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
61656 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
61657 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
61658 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
61659 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
61660 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
61661 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
61662 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
61663 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
61664 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
61665 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
61666 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
61667 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
61668 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
61669 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
61670 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
61671 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
61672 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
61673 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
61674 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
61675 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
61676 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
61677 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
61678 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
61679 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
61680 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
61681 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
61682 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
61683 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
61684 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
61685 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
61686 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
61687 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
61688 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
61689 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
61690 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
61691 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
61692 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
61693 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
61694 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
61695 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
61696 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
61697 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
61698 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
61699 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
61700 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
61701 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
61702 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
61703 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
61704 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
61705 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
61706 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
61707 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
61708 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
61709 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
61710 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
61711 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
61712 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
61713 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
61714 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
61715 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
61716 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
61717 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
61718 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
61719 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
61720 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
61721 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
61722 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
61723 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
61724 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
61725 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
61726 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
61727 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
61728 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
61729 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
61730 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
61731 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
61732 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
61733 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
61734 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
61735 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
61736 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
61737 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
61738 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
61739 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
61740 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
61741 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
61742 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
61743 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
61744 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
61745 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
61746 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
61747 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
61748 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
61749 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
61750 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
61751 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
61752 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
61753 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
61754 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
61755 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
61756 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
61757 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
61758 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
61759 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
61760 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
61761 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
61762 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
61763 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
61764 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
61765 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
61766 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
61767 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
61768 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
61769 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
61770 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
61771 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
61772 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
61773 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
61774 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
61775 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
61776 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
61777 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
61778 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
61779 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
61780 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
61781 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
61782 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
61783 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
61784 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
61785 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
61786 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
61787 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
61788 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
61789 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
61790 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
61791 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
61792 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
61793 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
61794 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
61795 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
61796 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
61797 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
61798 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
61799 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
61800 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
61801 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
61802 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
61803 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
61804 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
61805
61806 // Initialize threading, some globals and such
61807 __wxPyPreStart(d);
61808
61809
61810 // Although these are defined in __version__ they need to be here too so
61811 // that an assert can be done to ensure that the wxPython and the wxWindows
61812 // versions match.
61813 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
61814 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
61815 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
61816
61817 }
61818
wxWidgets (Impactor)